(function () {
  'use strict';

  /*! DateTime picker for DataTables.net v1.0.1
	 *
	 * ©2020 SpryMedia Ltd, all rights reserved.
	 * License: MIT datatables.net/license/mit
	 */

  /**
   * @summary     DateTime picker for DataTables.net
   * @version     1.0.1
   * @file        dataTables.dateTime.js
   * @author      SpryMedia Ltd
   * @contact     www.datatables.net/contact
   */
  (function (factory) {
    if (typeof define === 'function' && define.amd) {
      // AMD
      define(['jquery'], function ($) {
        return factory($, window, document);
      });
    } else if (typeof exports === 'object') {
      // CommonJS
      module.exports = function (root, $) {
        if (!root) {
          root = window;
        }

        return factory($, root, root.document);
      };
    } else {
      // Browser
      factory(jQuery, window, document);
    }
  }(function ($, window, document, undefined$1) {

    // Support libraries which support a Moment like API
    var dateLib = window.moment
      ? window.moment
      : window.dayjs
        ? window.dayjs
        : null;

    /*
	 * This file provides a DateTime GUI picker (calendar and time input). Only the
	 * format YYYY-MM-DD is supported without additional software, but the end user
	 * experience can be greatly enhanced by including the momentjs or dayjs library
	 * which provide date / time parsing and formatting options.
	 *
	 * This functionality is required because the HTML5 date and datetime input
	 * types are not widely supported in desktop browsers.
	 *
	 * Constructed by using:
	 *
	 *     new DateTime( input, opts )
	 *
	 * where `input` is the HTML input element to use and `opts` is an object of
	 * options based on the `DateTime.defaults` object.
	 */
    var DateTime = function (input, opts) {
      this.c = $.extend(true, {}, DateTime.defaults, opts);
      var classPrefix = this.c.classPrefix;
      var i18n = this.c.i18n;

      // Only IS8601 dates are supported without moment pr dayjs
      if (!dateLib && this.c.format !== 'YYYY-MM-DD') {
        throw "DateTime: Without momentjs or dayjs only the format 'YYYY-MM-DD' can be used";
      }

      // Min and max need to be `Date` objects in the config
      if (typeof this.c.minDate === 'string') {
        this.c.minDate = new Date(this.c.minDate);
      }
      if (typeof this.c.maxDate === 'string') {
        this.c.maxDate = new Date(this.c.maxDate);
      }

      // DOM structure
      var structure = $(
        '<div class="' + classPrefix + '">' +
        '<div class="' + classPrefix + '-date">' +
        '<div class="' + classPrefix + '-title">' +
        '<div class="' + classPrefix + '-iconLeft">' +
        '<button>' + i18n.previous + '</button>' +
        '</div>' +
        '<div class="' + classPrefix + '-iconRight">' +
        '<button>' + i18n.next + '</button>' +
        '</div>' +
        '<div class="' + classPrefix + '-label">' +
        '<span></span>' +
        '<select class="' + classPrefix + '-month"></select>' +
        '</div>' +
        '<div class="' + classPrefix + '-label">' +
        '<span></span>' +
        '<select class="' + classPrefix + '-year"></select>' +
        '</div>' +
        '</div>' +
        '<div class="' + classPrefix + '-calendar"></div>' +
        '</div>' +
        '<div class="' + classPrefix + '-time">' +
        '<div class="' + classPrefix + '-hours"></div>' +
        '<div class="' + classPrefix + '-minutes"></div>' +
        '<div class="' + classPrefix + '-seconds"></div>' +
        '</div>' +
        '<div class="' + classPrefix + '-error"></div>' +
        '</div>'
      );

      this.dom = {
        container: structure,
        date: structure.find('.' + classPrefix + '-date'),
        title: structure.find('.' + classPrefix + '-title'),
        calendar: structure.find('.' + classPrefix + '-calendar'),
        time: structure.find('.' + classPrefix + '-time'),
        error: structure.find('.' + classPrefix + '-error'),
        input: $(input)
      };

      this.s = {
        /** @type {Date} Date value that the picker has currently selected */
        d: null,

        /** @type {Date} Date of the calendar - might not match the value */
        display: null,

        /** @type {number} Used to select minutes in a range where the range base is itself unavailable */
        minutesRange: null,

        /** @type {number} Used to select minutes in a range where the range base is itself unavailable */
        secondsRange: null,

        /** @type {String} Unique namespace string for this instance */
        namespace: 'dateime-' + (DateTime._instance++),

        /** @type {Object} Parts of the picker that should be shown */
        parts: {
          date: this.c.format.match(/[YMD]|L(?!T)|l/) !== null,
          time: this.c.format.match(/[Hhm]|LT|LTS/) !== null,
          seconds: this.c.format.indexOf('s') !== -1,
          hours12: this.c.format.match(/[haA]/) !== null
        }
      };

      this.dom.container
        .append(this.dom.date)
        .append(this.dom.time)
        .append(this.dom.error);

      this.dom.date
        .append(this.dom.title)
        .append(this.dom.calendar);

      this._constructor();
    };

    $.extend(DateTime.prototype, {
      /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
		 * Public
		 */

      /**
       * Destroy the control
       */
      destroy: function () {
        this._hide(true);
        this.dom.container.off().empty();
        this.dom.input.off('.datetime');
      },

      errorMsg: function (msg) {
        var error = this.dom.error;

        if (msg) {
          error.html(msg);
        } else {
          error.empty();
        }

        return this;
      },

      hide: function () {
        this._hide();

        return this;
      },

      max: function (date) {
        this.c.maxDate = typeof date === 'string'
          ? new Date(date)
          : date;

        this._optionsTitle();
        this._setCalander();

        return this;
      },

      min: function (date) {
        this.c.minDate = typeof date === 'string'
          ? new Date(date)
          : date;

        this._optionsTitle();
        this._setCalander();

        return this;
      },

      /**
       * Check if an element belongs to this control
       *
       * @param  {node} node Element to check
       * @return {boolean}   true if owned by this control, false otherwise
       */
      owns: function (node) {
        return $(node).parents().filter(this.dom.container).length > 0;
      },

      /**
       * Get / set the value
       *
       * @param  {string|Date} set   Value to set
       * @param  {boolean} [write=true] Flag to indicate if the formatted value
       *   should be written into the input element
       */
      val: function (set, write) {
        if (set === undefined$1) {
          return this.s.d;
        }

        if (set instanceof Date) {
          this.s.d = this._dateToUtc(set);
        } else if (set === null || set === '') {
          this.s.d = null;
        } else if (set === '--now') {
          this.s.d = new Date();
        } else if (typeof set === 'string') {
          if (dateLib) {
            // Use moment or dayjs if possible (even for ISO8601 strings, since it
            // will correctly handle 0000-00-00 and the like)
            var m = dateLib.utc(set, this.c.format, this.c.locale, this.c.strict);
            this.s.d = m.isValid() ? m.toDate() : null;
          } else {
            // Else must be using ISO8601 without a date library (constructor would
            // have thrown an error otherwise)
            var match = set.match(/(\d{4})\-(\d{2})\-(\d{2})/);
            this.s.d = match ?
              new Date(Date.UTC(match[1], match[2] - 1, match[3])) :
              null;
          }
        }

        if (write || write === undefined$1) {
          if (this.s.d) {
            this._writeOutput();
          } else {
            // The input value was not valid...
            this.dom.input.val(set);
          }
        }

        // We need a date to be able to display the calendar at all
        if (!this.s.d) {
          this.s.d = this._dateToUtc(new Date());
        }

        this.s.display = new Date(this.s.d.toString());

        // Set the day of the month to be 1 so changing between months doesn't
        // run into issues when going from day 31 to 28 (for example)
        this.s.display.setUTCDate(1);

        // Update the display elements for the new value
        this._setTitle();
        this._setCalander();
        this._setTime();

        return this;
      },


      /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
		 * Constructor
		 */

      /**
       * Build the control and assign initial event handlers
       *
       * @private
       */
      _constructor: function () {
        var that = this;
        var classPrefix = this.c.classPrefix;
        var onChange = function () {
          that.c.onChange.call(that, that.dom.input.val(), that.s.d, that.dom.input);
        };

        if (!this.s.parts.date) {
          this.dom.date.css('display', 'none');
        }

        if (!this.s.parts.time) {
          this.dom.time.css('display', 'none');
        }

        if (!this.s.parts.seconds) {
          this.dom.time.children('div.' + classPrefix + '-seconds').remove();
          this.dom.time.children('span').eq(1).remove();
        }

        // Render the options
        this._optionsTitle();

        window.allan = this;

        // When attached to a hidden input, we always show the input picker, and
        // do so inline
        if (this.dom.input.attr('type') === 'hidden') {
          this.dom.container.addClass('inline');
          this.c.attachTo = 'input';

          this.val(this.dom.input.val(), false);
          this._show();
        }

        // Trigger the display of the widget when clicking or focusing on the
        // input element
        this.dom.input
          .attr('autocomplete', 'off')
          .on('focus.datetime click.datetime', function () {
            // If already visible - don't do anything
            if (that.dom.container.is(':visible') || that.dom.input.is(':disabled')) {
              return;
            }

            // In case the value has changed by text
            that.val(that.dom.input.val(), false);

            that._show();
          })
          .on('keyup.datetime', function () {
            // Update the calendar's displayed value as the user types
            if (that.dom.container.is(':visible')) {
              that.val(that.dom.input.val(), false);
            }
          });

        // Main event handlers for input in the widget
        this.dom.container
          .on('change', 'select', function () {
            var select = $(this);
            var val = select.val();

            if (select.hasClass(classPrefix + '-month')) {
              // Month select
              that._correctMonth(that.s.display, val);
              that._setTitle();
              that._setCalander();
            } else if (select.hasClass(classPrefix + '-year')) {
              // Year select
              that.s.display.setUTCFullYear(val);
              that._setTitle();
              that._setCalander();
            } else if (select.hasClass(classPrefix + '-hours') || select.hasClass(classPrefix + '-ampm')) {
              // Hours - need to take account of AM/PM input if present
              if (that.s.parts.hours12) {
                var hours = $(that.dom.container).find('.' + classPrefix + '-hours').val() * 1;
                var pm = $(that.dom.container).find('.' + classPrefix + '-ampm').val() === 'pm';

                that.s.d.setUTCHours(hours === 12 && !pm ?
                  0 :
                  pm && hours !== 12 ?
                    hours + 12 :
                    hours
                );
              } else {
                that.s.d.setUTCHours(val);
              }

              that._setTime();
              that._writeOutput(true);

              onChange();
            } else if (select.hasClass(classPrefix + '-minutes')) {
              // Minutes select
              that.s.d.setUTCMinutes(val);
              that._setTime();
              that._writeOutput(true);

              onChange();
            } else if (select.hasClass(classPrefix + '-seconds')) {
              // Seconds select
              that.s.d.setSeconds(val);
              that._setTime();
              that._writeOutput(true);

              onChange();
            }

            that.dom.input.focus();
            that._position();
          })
          .on('click', function (e) {
            var d = that.s.d;
            var nodeName = e.target.nodeName.toLowerCase();
            var target = nodeName === 'span' ?
              e.target.parentNode :
              e.target;

            nodeName = target.nodeName.toLowerCase();

            if (nodeName === 'select') {
              return;
            }

            e.stopPropagation();

            if (nodeName === 'button') {
              var button = $(target);
              var parent = button.parent();

              if (parent.hasClass('disabled') && !parent.hasClass('range')) {
                button.blur();
                return;
              }

              if (parent.hasClass(classPrefix + '-iconLeft')) {
                // Previous month
                that.s.display.setUTCMonth(that.s.display.getUTCMonth() - 1);
                that._setTitle();
                that._setCalander();

                that.dom.input.focus();
              } else if (parent.hasClass(classPrefix + '-iconRight')) {
                // Next month
                that._correctMonth(that.s.display, that.s.display.getUTCMonth() + 1);
                that._setTitle();
                that._setCalander();

                that.dom.input.focus();
              } else if (button.parents('.' + classPrefix + '-time').length) {
                var val = button.data('value');
                var unit = button.data('unit');

                if (unit === 'minutes') {
                  if (parent.hasClass('disabled') && parent.hasClass('range')) {
                    that.s.minutesRange = val;
                    that._setTime();
                    return;
                  } else {
                    that.s.minutesRange = null;
                  }
                }

                if (unit === 'seconds') {
                  if (parent.hasClass('disabled') && parent.hasClass('range')) {
                    that.s.secondsRange = val;
                    that._setTime();
                    return;
                  } else {
                    that.s.secondsRange = null;
                  }
                }

                // Specific to hours for 12h clock
                if (val === 'am') {
                  if (d.getUTCHours() >= 12) {
                    val = d.getUTCHours() - 12;
                  } else {
                    return;
                  }
                } else if (val === 'pm') {
                  if (d.getUTCHours() < 12) {
                    val = d.getUTCHours() + 12;
                  } else {
                    return;
                  }
                }

                var set = unit === 'hours' ?
                  'setUTCHours' :
                  unit === 'minutes' ?
                    'setUTCMinutes' :
                    'setSeconds';

                d[set](val);
                that._setTime();
                that._writeOutput(true);
                onChange();
              } else {
                // Calendar click
                if (!d) {
                  d = that._dateToUtc(new Date());
                }

                // Can't be certain that the current day will exist in
                // the new month, and likewise don't know that the
                // new day will exist in the old month, But 1 always
                // does, so we can change the month without worry of a
                // recalculation being done automatically by `Date`
                d.setUTCDate(1);
                d.setUTCFullYear(button.data('year'));
                d.setUTCMonth(button.data('month'));
                d.setUTCDate(button.data('day'));

                that._writeOutput(true);

                // Don't hide if there is a time picker, since we want to
                // be able to select a time as well.
                if (!that.s.parts.time) {
                  // This is annoying but IE has some kind of async
                  // behaviour with focus and the focus from the above
                  // write would occur after this hide - resulting in the
                  // calendar opening immediately
                  setTimeout(function () {
                    that._hide();
                  }, 10);
                } else {
                  that._setCalander();
                }

                onChange();
              }
            } else {
              // Click anywhere else in the widget - return focus to the
              // input element
              that.dom.input.focus();
            }
          });
      },


      /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
		 * Private
		 */

      /**
       * Compare the date part only of two dates - this is made super easy by the
       * toDateString method!
       *
       * @param  {Date} a Date 1
       * @param  {Date} b Date 2
       * @private
       */
      _compareDates: function (a, b) {
        // Can't use toDateString as that converts to local time
        return this._dateToUtcString(a) === this._dateToUtcString(b);
      },

      /**
       * When changing month, take account of the fact that some months don't have
       * the same number of days. For example going from January to February you
       * can have the 31st of Jan selected and just add a month since the date
       * would still be 31, and thus drop you into March.
       *
       * @param  {Date} date  Date - will be modified
       * @param  {integer} month Month to set
       * @private
       */
      _correctMonth: function (date, month) {
        var days = this._daysInMonth(date.getUTCFullYear(), month);
        var correctDays = date.getUTCDate() > days;

        date.setUTCMonth(month);

        if (correctDays) {
          date.setUTCDate(days);
          date.setUTCMonth(month);
        }
      },

      /**
       * Get the number of days in a method. Based on
       * http://stackoverflow.com/a/4881951 by Matti Virkkunen
       *
       * @param  {integer} year  Year
       * @param  {integer} month Month (starting at 0)
       * @private
       */
      _daysInMonth: function (year, month) {
        //
        var isLeap = ((year % 4) === 0 && ((year % 100) !== 0 || (year % 400) === 0));
        var months = [31, (isLeap ? 29 : 28), 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];

        return months[month];
      },

      /**
       * Create a new date object which has the UTC values set to the local time.
       * This allows the local time to be used directly for the library which
       * always bases its calculations and display on UTC.
       *
       * @param  {Date} s Date to "convert"
       * @return {Date}   Shifted date
       */
      _dateToUtc: function (s) {
        return new Date(Date.UTC(
          s.getFullYear(), s.getMonth(), s.getDate(),
          s.getHours(), s.getMinutes(), s.getSeconds()
        ));
      },

      /**
       * Create a UTC ISO8601 date part from a date object
       *
       * @param  {Date} d Date to "convert"
       * @return {string} ISO formatted date
       */
      _dateToUtcString: function (d) {
        return d.getUTCFullYear() + '-' +
          this._pad(d.getUTCMonth() + 1) + '-' +
          this._pad(d.getUTCDate());
      },

      /**
       * Hide the control and remove events related to its display
       *
       * @private
       */
      _hide: function (destroy) {
        if (!destroy && this.dom.input.attr('type') === 'hidden') {
          return;
        }

        var namespace = this.s.namespace;

        this.dom.container.detach();

        $(window).off('.' + namespace);
        $(document).off('keydown.' + namespace);
        $('div.dataTables_scrollBody').off('scroll.' + namespace);
        $('div.DTE_Body_Content').off('scroll.' + namespace);
        $('body').off('click.' + namespace);
      },

      /**
       * Convert a 24 hour value to a 12 hour value
       *
       * @param  {integer} val 24 hour value
       * @return {integer}     12 hour value
       * @private
       */
      _hours24To12: function (val) {
        return val === 0 ?
          12 :
          val > 12 ?
            val - 12 :
            val;
      },

      /**
       * Generate the HTML for a single day in the calendar - this is basically
       * and HTML cell with a button that has data attributes so we know what was
       * clicked on (if it is clicked on) and a bunch of classes for styling.
       *
       * @param  {object} day Day object from the `_htmlMonth` method
       * @return {string}     HTML cell
       */
      _htmlDay: function (day) {
        if (day.empty) {
          return '<td class="empty"></td>';
        }

        var classes = ['selectable'];
        var classPrefix = this.c.classPrefix;

        if (day.disabled) {
          classes.push('disabled');
        }

        if (day.today) {
          classes.push('now');
        }

        if (day.selected) {
          classes.push('selected');
        }

        return '<td data-day="' + day.day + '" class="' + classes.join(' ') + '">' +
          '<button class="' + classPrefix + '-button ' + classPrefix + '-day" type="button" ' + 'data-year="' + day.year + '" data-month="' + day.month + '" data-day="' + day.day + '">' +
          '<span>' + day.day + '</span>' +
          '</button>' +
          '</td>';
      },


      /**
       * Create the HTML for a month to be displayed in the calendar table.
       *
       * Based upon the logic used in Pikaday - MIT licensed
       * Copyright (c) 2014 David Bushell
       * https://github.com/dbushell/Pikaday
       *
       * @param  {integer} year  Year
       * @param  {integer} month Month (starting at 0)
       * @return {string} Calendar month HTML
       * @private
       */
      _htmlMonth: function (year, month) {
        var now = this._dateToUtc(new Date()),
          days = this._daysInMonth(year, month),
          before = new Date(Date.UTC(year, month, 1)).getUTCDay(),
          data = [],
          row = [];

        if (this.c.firstDay > 0) {
          before -= this.c.firstDay;

          if (before < 0) {
            before += 7;
          }
        }

        var cells = days + before,
          after = cells;

        while (after > 7) {
          after -= 7;
        }

        cells += 7 - after;

        var minDate = this.c.minDate;
        var maxDate = this.c.maxDate;

        if (minDate) {
          minDate.setUTCHours(0);
          minDate.setUTCMinutes(0);
          minDate.setSeconds(0);
        }

        if (maxDate) {
          maxDate.setUTCHours(23);
          maxDate.setUTCMinutes(59);
          maxDate.setSeconds(59);
        }

        for (var i = 0, r = 0; i < cells; i++) {
          var day = new Date(Date.UTC(year, month, 1 + (i - before))),
            selected = this.s.d ? this._compareDates(day, this.s.d) : false,
            today = this._compareDates(day, now),
            empty = i < before || i >= (days + before),
            disabled = (minDate && day < minDate) ||
              (maxDate && day > maxDate);

          var disableDays = this.c.disableDays;
          if (Array.isArray(disableDays) && $.inArray(day.getUTCDay(), disableDays) !== -1) {
            disabled = true;
          } else if (typeof disableDays === 'function' && disableDays(day) === true) {
            disabled = true;
          }

          var dayConfig = {
            day: 1 + (i - before),
            month: month,
            year: year,
            selected: selected,
            today: today,
            disabled: disabled,
            empty: empty
          };

          row.push(this._htmlDay(dayConfig));

          if (++r === 7) {
            if (this.c.showWeekNumber) {
              row.unshift(this._htmlWeekOfYear(i - before, month, year));
            }

            data.push('<tr>' + row.join('') + '</tr>');
            row = [];
            r = 0;
          }
        }

        var classPrefix = this.c.classPrefix;
        var className = classPrefix + '-table';
        if (this.c.showWeekNumber) {
          className += ' weekNumber';
        }

        // Show / hide month icons based on min/max
        if (minDate) {
          var underMin = minDate >= new Date(Date.UTC(year, month, 1, 0, 0, 0));

          this.dom.title.find('div.' + classPrefix + '-iconLeft')
            .css('display', underMin ? 'none' : 'block');
        }

        if (maxDate) {
          var overMax = maxDate < new Date(Date.UTC(year, month + 1, 1, 0, 0, 0));

          this.dom.title.find('div.' + classPrefix + '-iconRight')
            .css('display', overMax ? 'none' : 'block');
        }

        return '<table class="' + className + '">' +
          '<thead>' +
          this._htmlMonthHead() +
          '</thead>' +
          '<tbody>' +
          data.join('') +
          '</tbody>' +
          '</table>';
      },

      /**
       * Create the calendar table's header (week days)
       *
       * @return {string} HTML cells for the row
       * @private
       */
      _htmlMonthHead: function () {
        var a = [];
        var firstDay = this.c.firstDay;
        var i18n = this.c.i18n;

        // Take account of the first day shift
        var dayName = function (day) {
          day += firstDay;

          while (day >= 7) {
            day -= 7;
          }

          return i18n.weekdays[day];
        };

        // Empty cell in the header
        if (this.c.showWeekNumber) {
          a.push('<th></th>');
        }

        for (var i = 0; i < 7; i++) {
          a.push('<th>' + dayName(i) + '</th>');
        }

        return a.join('');
      },

      /**
       * Create a cell that contains week of the year - ISO8601
       *
       * Based on https://stackoverflow.com/questions/6117814/ and
       * http://techblog.procurios.nl/k/n618/news/view/33796/14863/
       *
       * @param  {integer} d Day of month
       * @param  {integer} m Month of year (zero index)
       * @param  {integer} y Year
       * @return {string}
       * @private
       */
      _htmlWeekOfYear: function (d, m, y) {
        var date = new Date(y, m, d, 0, 0, 0, 0);

        // First week of the year always has 4th January in it
        date.setDate(date.getDate() + 4 - (date.getDay() || 7));

        var oneJan = new Date(y, 0, 1);
        var weekNum = Math.ceil((((date - oneJan) / 86400000) + 1) / 7);

        return '<td class="' + this.c.classPrefix + '-week">' + weekNum + '</td>';
      },

      /**
       * Create option elements from a range in an array
       *
       * @param  {string} selector Class name unique to the select element to use
       * @param  {array} values   Array of values
       * @param  {array} [labels] Array of labels. If given must be the same
       *   length as the values parameter.
       * @private
       */
      _options: function (selector, values, labels) {
        if (!labels) {
          labels = values;
        }

        var select = this.dom.container.find('select.' + this.c.classPrefix + '-' + selector);
        select.empty();

        for (var i = 0, ien = values.length; i < ien; i++) {
          select.append('<option value="' + values[i] + '">' + labels[i] + '</option>');
        }
      },

      /**
       * Set an option and update the option's span pair (since the select element
       * has opacity 0 for styling)
       *
       * @param  {string} selector Class name unique to the select element to use
       * @param  {*}      val      Value to set
       * @private
       */
      _optionSet: function (selector, val) {
        var select = this.dom.container.find('select.' + this.c.classPrefix + '-' + selector);
        var span = select.parent().children('span');

        select.val(val);

        var selected = select.find('option:selected');
        span.html(selected.length !== 0 ?
          selected.text() :
          this.c.i18n.unknown
        );
      },

      /**
       * Create time options list.
       *
       * @param  {string} unit Time unit - hours, minutes or seconds
       * @param  {integer} count Count range - 12, 24 or 60
       * @param  {integer} val Existing value for this unit
       * @param  {integer[]} allowed Values allow for selection
       * @param  {integer} range Override range
       * @private
       */
      _optionsTime: function (unit, count, val, allowed, range) {
        var classPrefix = this.c.classPrefix;
        var container = this.dom.container.find('div.' + classPrefix + '-' + unit);
        var i, j;
        var render = count === 12 ?
          function (i) {
            return i;
          } :
          this._pad;
        var classPrefix = this.c.classPrefix;
        var className = classPrefix + '-table';
        var i18n = this.c.i18n;

        if (!container.length) {
          return;
        }

        var a = '';
        var span = 10;
        var button = function (value, label, className) {
          // Shift the value for PM
          if (count === 12 && typeof value === 'number') {
            if (val >= 12) {
              value += 12;
            }

            if (value == 12) {
              value = 0;
            } else if (value == 24) {
              value = 12;
            }
          }

          var selected = val === value || (value === 'am' && val < 12) || (value === 'pm' && val >= 12) ?
            'selected' :
            '';

          if (allowed && $.inArray(value, allowed) === -1) {
            selected += ' disabled';
          }

          if (className) {
            selected += ' ' + className;
          }

          return '<td class="selectable ' + selected + '">' +
            '<button class="' + classPrefix + '-button ' + classPrefix + '-day" type="button" data-unit="' + unit + '" data-value="' + value + '">' +
            '<span>' + label + '</span>' +
            '</button>' +
            '</td>';
        };

        if (count === 12) {
          // Hours with AM/PM
          a += '<tr>';

          for (i = 1; i <= 6; i++) {
            a += button(i, render(i));
          }
          a += button('am', i18n.amPm[0]);

          a += '</tr>';
          a += '<tr>';

          for (i = 7; i <= 12; i++) {
            a += button(i, render(i));
          }
          a += button('pm', i18n.amPm[1]);
          a += '</tr>';

          span = 7;
        } else if (count === 24) {
          // Hours - 24
          var c = 0;
          for (j = 0; j < 4; j++) {
            a += '<tr>';
            for (i = 0; i < 6; i++) {
              a += button(c, render(c));
              c++;
            }
            a += '</tr>';
          }

          span = 6;
        } else {
          // Minutes and seconds
          a += '<tr>';
          for (j = 0; j < 60; j += 10) {
            a += button(j, render(j), 'range');
          }
          a += '</tr>';

          // Slight hack to allow for the different number of columns
          a += '</tbody></thead><table class="' + className + ' ' + className + '-nospace"><tbody>';

          var start = range !== null ?
            range :
            Math.floor(val / 10) * 10;

          a += '<tr>';
          for (j = start + 1; j < start + 10; j++) {
            a += button(j, render(j));
          }
          a += '</tr>';

          span = 6;
        }

        container
          .empty()
          .append(
            '<table class="' + className + '">' +
            '<thead><tr><th colspan="' + span + '">' +
            i18n[unit] +
            '</th></tr></thead>' +
            '<tbody>' +
            a +
            '</tbody>' +
            '</table>'
          );
      },

      /**
       * Create the options for the month and year
       *
       * @param  {integer} year  Year
       * @param  {integer} month Month (starting at 0)
       * @private
       */
      _optionsTitle: function () {
        var i18n = this.c.i18n;
        var min = this.c.minDate;
        var max = this.c.maxDate;
        var minYear = min ? min.getFullYear() : null;
        var maxYear = max ? max.getFullYear() : null;

        var i = minYear !== null ? minYear : new Date().getFullYear() - this.c.yearRange;
        var j = maxYear !== null ? maxYear : new Date().getFullYear() + this.c.yearRange;

        this._options('month', this._range(0, 11), i18n.months);
        this._options('year', this._range(i, j));
      },

      /**
       * Simple two digit pad
       *
       * @param  {integer} i      Value that might need padding
       * @return {string|integer} Padded value
       * @private
       */
      _pad: function (i) {
        return i < 10 ? '0' + i : i;
      },

      /**
       * Position the calendar to look attached to the input element
       * @private
       */
      _position: function () {
        var offset = this.c.attachTo === 'input' ? this.dom.input.position() : this.dom.input.offset();
        var container = this.dom.container;
        var inputHeight = this.dom.input.outerHeight();

        if (container.hasClass('inline')) {
          container.insertAfter(this.dom.input);
          return;
        }

        if (this.s.parts.date && this.s.parts.time && $(window).width() > 550) {
          container.addClass('horizontal');
        } else {
          container.removeClass('horizontal');
        }

        if (this.c.attachTo === 'input') {
          container
            .css({
              top: offset.top + inputHeight,
              left: offset.left
            })
            .insertAfter(this.dom.input);
        } else {
          container
            .css({
              top: offset.top + inputHeight,
              left: offset.left
            })
            .appendTo('body');
        }

        var calHeight = container.outerHeight();
        var calWidth = container.outerWidth();
        var scrollTop = $(window).scrollTop();

        // Correct to the bottom
        if (offset.top + inputHeight + calHeight - scrollTop > $(window).height()) {
          var newTop = offset.top - calHeight;

          container.css('top', newTop < 0 ? 0 : newTop);
        }

        // Correct to the right
        if (calWidth + offset.left > $(window).width()) {
          var newLeft = $(window).width() - calWidth;

          // Account for elements which are inside a position absolute element
          if (this.c.attachTo === 'input') {
            newLeft -= $(container).offsetParent().offset().left;
          }

          container.css('left', newLeft < 0 ? 0 : newLeft);
        }
      },

      /**
       * Create a simple array with a range of values
       *
       * @param  {integer} start   Start value (inclusive)
       * @param  {integer} end     End value (inclusive)
       * @param  {integer} [inc=1] Increment value
       * @return {array}           Created array
       * @private
       */
      _range: function (start, end, inc) {
        var a = [];

        if (!inc) {
          inc = 1;
        }

        for (var i = start; i <= end; i += inc) {
          a.push(i);
        }

        return a;
      },

      /**
       * Redraw the calendar based on the display date - this is a destructive
       * operation
       *
       * @private
       */
      _setCalander: function () {
        if (this.s.display) {
          this.dom.calendar
            .empty()
            .append(this._htmlMonth(
              this.s.display.getUTCFullYear(),
              this.s.display.getUTCMonth()
            ));
        }
      },

      /**
       * Set the month and year for the calendar based on the current display date
       *
       * @private
       */
      _setTitle: function () {
        this._optionSet('month', this.s.display.getUTCMonth());
        this._optionSet('year', this.s.display.getUTCFullYear());
      },

      /**
       * Set the time based on the current value of the widget
       *
       * @private
       */
      _setTime: function () {
        var that = this;
        var d = this.s.d;
        var hours = d ? d.getUTCHours() : 0;
        var allowed = function (prop) { // Backwards compt with `Increment` option
          return that.c[prop + 'Available'] ?
            that.c[prop + 'Available'] :
            that._range(0, 59, that.c[prop + 'Increment']);
        };

        this._optionsTime('hours', this.s.parts.hours12 ? 12 : 24, hours, this.c.hoursAvailable);
        this._optionsTime('minutes', 60, d ? d.getUTCMinutes() : 0, allowed('minutes'), this.s.minutesRange);
        this._optionsTime('seconds', 60, d ? d.getSeconds() : 0, allowed('seconds'), this.s.secondsRange);
      },

      /**
       * Show the widget and add events to the document required only while it
       * is displayed
       *
       * @private
       */
      _show: function () {
        var that = this;
        var namespace = this.s.namespace;

        this._position();

        // Need to reposition on scroll
        $(window).on('scroll.' + namespace + ' resize.' + namespace, function () {
          that._hide();
        });

        $('div.DTE_Body_Content').on('scroll.' + namespace, function () {
          that._hide();
        });

        $('div.dataTables_scrollBody').on('scroll.' + namespace, function () {
          that._hide();
        });

        var offsetParent = this.dom.input[0].offsetParent;

        if (offsetParent !== document.body) {
          $(offsetParent).on('scroll.' + namespace, function () {
            that._hide();
          });
        }

        // On tab focus will move to a different field (no keyboard navigation
        // in the date picker - this might need to be changed).
        $(document).on('keydown.' + namespace, function (e) {
          if (
            e.keyCode === 9 || // tab
            e.keyCode === 27 || // esc
            e.keyCode === 13    // return
          ) {
            that._hide();
          }
        });

        // Hide if clicking outside of the widget - but in a different click
        // event from the one that was used to trigger the show (bubble and
        // inline)
        setTimeout(function () {
          $('body').on('click.' + namespace, function (e) {
            var parents = $(e.target).parents();

            if (!parents.filter(that.dom.container).length && e.target !== that.dom.input[0]) {
              that._hide();
            }
          });
        }, 10);
      },

      /**
       * Write the formatted string to the input element this control is attached
       * to
       *
       * @private
       */
      _writeOutput: function (focus) {
        var date = this.s.d;

        // Use moment or dayjs if possible - otherwise it must be ISO8601 (or the
        // constructor would have thrown an error)
        var out = dateLib ?
          dateLib.utc(date, undefined$1, this.c.locale, this.c.strict).format(this.c.format) :
          date.getUTCFullYear() + '-' +
          this._pad(date.getUTCMonth() + 1) + '-' +
          this._pad(date.getUTCDate());

        this.dom.input
          .val(out)
          .trigger('change', {write: date});

        if (this.dom.input.attr('type') === 'hidden') {
          this.val(out, false);
        }

        if (focus) {
          this.dom.input.focus();
        }
      }
    });

    /**
     * Use a specificmoment compatible date library
     */
    DateTime.use = function (lib) {
      dateLib = lib;
    };

    /**
     * For generating unique namespaces
     *
     * @type {Number}
     * @private
     */
    DateTime._instance = 0;

    /**
     * Defaults for the date time picker
     *
     * @type {Object}
     */
    DateTime.defaults = {
      attachTo: 'body',

      // Not documented - could be an internal property
      classPrefix: 'dt-datetime',

      // function or array of ints
      disableDays: null,

      // first day of the week (0: Sunday, 1: Monday, etc)
      firstDay: 1,

      format: 'YYYY-MM-DD',

      hoursAvailable: null,

      i18n: {
        previous: 'Previous',
        next: 'Next',
        months: ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'],
        weekdays: ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'],
        amPm: ['am', 'pm'],
        hours: 'Hour',
        minutes: 'Minute',
        seconds: 'Second',
        unknown: '-'
      },

      maxDate: null,

      minDate: null,

      minutesAvailable: null,

      minutesIncrement: 1, // deprecated

      strict: true,

      locale: 'en',

      onChange: function () {
      },

      secondsAvailable: null,

      secondsIncrement: 1, // deprecated

      // show the ISO week number at the head of the row
      showWeekNumber: false,

      // overruled by max / min date
      yearRange: 25
    };

    DateTime.version = '1.0.1';

    // Global export - if no conflicts
    if (!window.DateTime) {
      window.DateTime = DateTime;
    }

    // Make available via jQuery
    $.fn.dtDateTime = function (options) {
      return this.each(function () {
        new DateTime(this, options);
      });
    };

    // Attach to DataTables if present
    if ($.fn.dataTable) {
      $.fn.dataTable.DateTime = DateTime;
      $.fn.DataTable.DateTime = DateTime;
    }

    return DateTime;

  }));

  var $;
  var DataTable;
  var moment = window.moment;

  /**
   * Sets the value of jQuery for use in the file
   * @param jq the instance of jQuery to be set
   */
  function setJQuery(jq) {
    $ = jq;
    DataTable = jq.fn.dataTable;
  }

  /**
   * The Criteria class is used within SearchBuilder to represent a search criteria
   */
  var Criteria = /** @class */ (function () {
    function Criteria(table, opts, topGroup, index, depth) {
      var _this = this;
      if (index === void 0) {
        index = 0;
      }
      if (depth === void 0) {
        depth = 1;
      }
      // Check that the required version of DataTables is included
      if (!DataTable || !DataTable.versionCheck || !DataTable.versionCheck('1.10.0')) {
        throw new Error('SearchPane requires DataTables 1.10 or newer');
      }
      this.classes = $.extend(true, {}, Criteria.classes);
      // Get options from user and any extra conditions/column types defined by plug-ins
      this.c = $.extend(true, {}, Criteria.defaults, $.fn.dataTable.ext.searchBuilder, opts);
      var i18n = this.c.i18n;
      this.s = {
        condition: undefined,
        conditions: {},
        data: undefined,
        dataIdx: -1,
        dataPoints: [],
        depth: depth,
        dt: table,
        filled: false,
        index: index,
        momentFormat: false,
        topGroup: topGroup,
        type: '',
        value: []
      };
      this.dom = {
        buttons: $('<div/>')
          .addClass(this.classes.buttonContainer),
        condition: $('<select disabled/>')
          .addClass(this.classes.condition)
          .addClass(this.classes.dropDown)
          .addClass(this.classes.italic)
          .attr('autocomplete', 'hacking'),
        conditionTitle: $('<option value="" disabled selected hidden/>')
          .text(this.s.dt.i18n('searchBuilder.condition', i18n.condition)),
        container: $('<div/>')
          .addClass(this.classes.container),
        data: $('<select/>')
          .addClass(this.classes.data)
          .addClass(this.classes.dropDown)
          .addClass(this.classes.italic),
        dataTitle: $('<option value="" disabled selected hidden/>')
          .text(this.s.dt.i18n('searchBuilder.data', i18n.data)),
        defaultValue: $('<select disabled/>')
          .addClass(this.classes.value)
          .addClass(this.classes.dropDown),
        "delete": $('<button>&times</button>')
          .addClass(this.classes["delete"])
          .addClass(this.classes.button)
          .attr('title', this.s.dt.i18n('searchBuilder.deleteTitle', i18n.deleteTitle))
          .attr('type', 'button'),
        left: $('<button>\<</button>')
          .addClass(this.classes.left)
          .addClass(this.classes.button)
          .attr('title', this.s.dt.i18n('searchBuilder.leftTitle', i18n.leftTitle))
          .attr('type', 'button'),
        right: $('<button>\></button>')
          .addClass(this.classes.right)
          .addClass(this.classes.button)
          .attr('title', this.s.dt.i18n('searchBuilder.rightTitle', i18n.rightTitle))
          .attr('type', 'button'),
        value: [
          $('<select disabled/>').addClass(this.classes.value).addClass(this.classes.dropDown).addClass(this.classes.italic)
        ],
        valueTitle: $('<option value="--valueTitle--" selected/>').text(this.s.dt.i18n('searchBuilder.value', i18n.value))
      };
      // If the greyscale option is selected then add the class to add the grey colour to SearchBuilder
      if (this.c.greyscale) {
        $(this.dom.data).addClass(this.classes.greyscale);
        $(this.dom.condition).addClass(this.classes.greyscale);
        $(this.dom.defaultValue).addClass(this.classes.greyscale);
        for (var _i = 0, _a = this.dom.value; _i < _a.length; _i++) {
          var val = _a[_i];
          $(val).addClass(this.classes.greyscale);
        }
      }
      // For responsive design, adjust the criterias properties on the following events
      this.s.dt.on('draw.dtsp', function () {
        _this._adjustCriteria();
      });
      this.s.dt.on('buttons-action', function () {
        _this._adjustCriteria();
      });
      $(window).on('resize.dtsp', DataTable.util.throttle(function () {
        _this._adjustCriteria();
      }));
      this._buildCriteria();
      return this;
    }

    /**
     * Adds the left button to the criteria
     */
    Criteria.prototype.updateArrows = function (hasSiblings, redraw) {
      if (hasSiblings === void 0) {
        hasSiblings = false;
      }
      if (redraw === void 0) {
        redraw = true;
      }
      // Empty the container and append all of the elements in the correct order
      $(this.dom.container)
        .empty()
        .append(this.dom.data)
        .append(this.dom.condition)
        .append(this.dom.value[0]);
      // Trigger the inserted events for the value elements as they are inserted
      $(this.dom.value[0]).trigger('dtsb-inserted');
      for (var i = 1; i < this.dom.value.length; i++) {
        $(this.dom.container).append(this.dom.value[i]);
        $(this.dom.value[i]).trigger('dtsb-inserted');
      }
      // If this is a top level criteria then don't let it move left
      if (this.s.depth > 1) {
        $(this.dom.buttons).append(this.dom.left);
      }
      // If the depthLimit of the query has been hit then don't add the right button
      if ((this.c.depthLimit === false || this.s.depth < this.c.depthLimit) && hasSiblings) {
        $(this.dom.buttons).append(this.dom.right);
      } else {
        $(this.dom.right).remove();
      }
      $(this.dom.buttons).append(this.dom["delete"]);
      $(this.dom.container).append(this.dom.buttons);
      if (redraw) {
        // A different combination of arrows and selectors may lead to a need for responsive to be triggered
        this._adjustCriteria();
      }
    };
    /**
     * Destroys the criteria, removing listeners and container from the dom
     */
    Criteria.prototype.destroy = function () {
      // Turn off listeners
      $(this.dom.data).off('.dtsb');
      $(this.dom.condition).off('.dtsb');
      $(this.dom["delete"]).off('.dtsb');
      for (var _i = 0, _a = this.dom.value; _i < _a.length; _i++) {
        var val = _a[_i];
        $(val).off('.dtsb');
      }
      // Remove container from the dom
      $(this.dom.container).remove();
    };
    /**
     * Passes in the data for the row and compares it against this single criteria
     * @param rowData The data for the row to be compared
     * @returns boolean Whether the criteria has passed
     */
    Criteria.prototype.search = function (rowData, rowIdx) {
      var condition = this.s.conditions[this.s.condition];
      if (this.s.condition !== undefined && condition !== undefined) {
        // This check is in place for if a custom decimal character is in place
        if (this.s.type.indexOf('num') !== -1 && this.s.dt.settings()[0].oLanguage.sDecimal !== '') {
          rowData[this.s.dataIdx] = rowData[this.s.dataIdx].replace(this.s.dt.settings()[0].oLanguage.sDecimal, '.');
        }
        var filter = rowData[this.s.dataIdx];
        // If orthogonal data is in place we need to get it's values for searching
        if (this.c.orthogonal.search !== 'search') {
          var settings = this.s.dt.settings()[0];
          filter = settings.oApi._fnGetCellData(settings, rowIdx, this.s.dataIdx, typeof this.c.orthogonal === 'string' ?
            this.c.orthogonal :
            this.c.orthogonal.search);
        }
        if (this.s.type === 'array') {
          // Make sure we are working with an array
          if (!Array.isArray(filter)) {
            filter = [filter];
          }
          filter.sort();
        }
        return condition.search(filter, this.s.value, this);
      }
    };
    /**
     * Gets the details required to rebuild the criteria
     */
    Criteria.prototype.getDetails = function () {
      var value = this.s.value;
      // This check is in place for if a custom decimal character is in place
      if (this.s.type.indexOf('num') !== -1 && this.s.dt.settings()[0].oLanguage.sDecimal !== '') {
        for (var i = 0; i < this.s.value.length; i++) {
          if (this.s.value[i].indexOf('.') !== -1) {
            value[i] = this.s.value[i].replace('.', this.s.dt.settings()[0].oLanguage.sDecimal);
          }
        }
      }
      return {
        condition: this.s.condition,
        data: this.s.data,
        value: value
      };
    };
    /**
     * Getter for the node for the container of the criteria
     * @returns JQuery<HTMLElement> the node for the container
     */
    Criteria.prototype.getNode = function () {
      return this.dom.container;
    };
    /**
     * Populates the criteria data, condition and value(s) as far as has been selected
     */
    Criteria.prototype.populate = function () {
      this._populateData();
      // If the column index has been found attempt to select a condition
      if (this.s.dataIdx !== -1) {
        this._populateCondition();
        // If the condittion has been found attempt to select the values
        if (this.s.condition !== undefined) {
          this._populateValue();
        }
      }
    };
    /**
     * Rebuilds the criteria based upon the details passed in
     * @param loadedCriteria the details required to rebuild the criteria
     */
    Criteria.prototype.rebuild = function (loadedCriteria) {
      // Check to see if the previously selected data exists, if so select it
      var foundData = false;
      var dataIdx;
      this._populateData();
      // If a data selection has previously been made attempt to find and select it
      if (loadedCriteria.data !== undefined) {
        var italic_1 = this.classes.italic;
        var data_1 = this.dom.data;
        $(this.dom.data).children('option').each(function () {
          if ($(this).text() === loadedCriteria.data) {
            $(this).attr('selected', true);
            $(data_1).removeClass(italic_1);
            foundData = true;
            dataIdx = $(this).val();
          }
        });
      }
      // If the data has been found and selected then the condition can be populated and searched
      if (foundData) {
        this.s.data = loadedCriteria.data;
        this.s.dataIdx = dataIdx;
        $(this.dom.dataTitle).remove();
        this._populateCondition();
        $(this.dom.conditionTitle).remove();
        var condition_1;
        // Check to see if the previously selected condition exists, if so select it
        $(this.dom.condition).children('option').each(function () {
          if ((loadedCriteria.condition !== undefined &&
            $(this).val() === loadedCriteria.condition &&
            typeof loadedCriteria.condition === 'string')) {
            $(this).attr('selected', true);
            condition_1 = $(this).val();
          }
        });
        this.s.condition = condition_1;
        // If the condition has been found and selected then the value can be populated and searched
        if (this.s.condition !== undefined) {
          $(this.dom.conditionTitle).remove();
          $(this.dom.condition).removeClass(this.classes.italic);
          this._populateValue(loadedCriteria);
        } else {
          $(this.dom.conditionTitle).prependTo(this.dom.condition).attr('selected', true);
        }
      }
    };
    /**
     * Sets the listeners for the criteria
     */
    Criteria.prototype.setListeners = function () {
      var _this = this;
      $(this.dom.data)
        .unbind('input change')
        .on('input change', function () {
          $(_this.dom.dataTitle).attr('selected', false);
          $(_this.dom.data).removeClass(_this.classes.italic);
          _this.s.dataIdx = $(_this.dom.data).children('option:selected').val();
          _this.s.data = $(_this.dom.data).children('option:selected').text();
          _this.c.orthogonal = _this._getOptions().orthogonal;
          // When the data is changed, the values in condition and value may also change so need to renew them
          _this._clearCondition();
          _this._clearValue();
          _this._populateCondition();
          // If this criteria was previously active in the search then remove it from the search and trigger a new search
          if (_this.s.filled) {
            _this.s.filled = false;
            _this.s.dt.draw();
            _this.setListeners();
          }
          _this.s.dt.state.save();
        });
      $(this.dom.condition)
        .unbind('input change')
        .on('input change', function () {
          $(_this.dom.conditionTitle).attr('selected', false);
          $(_this.dom.condition).removeClass(_this.classes.italic);
          var condDisp = $(_this.dom.condition).children('option:selected').val();
          // Find the condition that has been selected and store it internally
          for (var _i = 0, _a = Object.keys(_this.s.conditions); _i < _a.length; _i++) {
            var cond = _a[_i];
            if (cond === condDisp) {
              _this.s.condition = condDisp;
              break;
            }
          }
          // When the condition is changed, the value selector may switch between a select element and an input element
          _this._clearValue();
          _this._populateValue();
          for (var _b = 0, _c = _this.dom.value; _b < _c.length; _b++) {
            var val = _c[_b];
            // If this criteria was previously active in the search then remove it from the search and trigger a new search
            if (_this.s.filled && $(_this.dom.container).has(val).length !== 0) {
              _this.s.filled = false;
              _this.s.dt.draw();
              _this.setListeners();
            }
          }
          _this.s.dt.draw();
        });
    };
    /**
     * Adjusts the criteria to make SearchBuilder responsive
     */
    Criteria.prototype._adjustCriteria = function () {
      // If this criteria is not present then don't bother adjusting it
      if ($(document).has(this.dom.container).length === 0) {
        return;
      }
      var valRight;
      var valWidth;
      var outmostval = this.dom.value[this.dom.value.length - 1];
      // Calculate the width and right value of the outmost value element
      if ($(this.dom.container).has(outmostval).length !== 0) {
        valWidth = $(outmostval).outerWidth(true);
        valRight = $(outmostval).offset().left + valWidth;
      } else {
        return;
      }
      var leftOffset = $(this.dom.left).offset();
      var rightOffset = $(this.dom.right).offset();
      var clearOffset = $(this.dom["delete"]).offset();
      var hasLeft = $(this.dom.container).has(this.dom.left).length !== 0;
      var hasRight = $(this.dom.container).has(this.dom.right).length !== 0;
      var buttonsLeft = hasLeft ?
        leftOffset.left :
        hasRight ?
          rightOffset.left :
          clearOffset.left;
      // Perform the responsive calculations and redraw where necessary
      if (buttonsLeft - valRight < 15 ||
        (hasLeft && leftOffset.top !== clearOffset.top) ||
        (hasRight && rightOffset.top !== clearOffset.top)) {
        $(this.dom.container).parent().addClass(this.classes.vertical);
        $(this.s.topGroup).trigger('dtsb-redrawContents');
      } else if (buttonsLeft -
        ($(this.dom.data).offset().left +
          $(this.dom.data).outerWidth(true) +
          $(this.dom.condition).outerWidth(true) +
          valWidth) > 15) {
        $(this.dom.container).parent().removeClass(this.classes.vertical);
        $(this.s.topGroup).trigger('dtsb-redrawContents');
      }
    };
    /**
     * Builds the elements of the dom together
     */
    Criteria.prototype._buildCriteria = function () {
      // Append Titles for select elements
      $(this.dom.data).append(this.dom.dataTitle);
      $(this.dom.condition).append(this.dom.conditionTitle);
      // Add elements to container
      $(this.dom.container)
        .append(this.dom.data)
        .append(this.dom.condition);
      for (var _i = 0, _a = this.dom.value; _i < _a.length; _i++) {
        var val = _a[_i];
        $(val).append(this.dom.valueTitle);
        $(this.dom.container).append(val);
      }
      // Add buttons to container
      $(this.dom.container)
        .append(this.dom["delete"])
        .append(this.dom.right);
      this.setListeners();
    };
    /**
     * Clears the condition select element
     */
    Criteria.prototype._clearCondition = function () {
      $(this.dom.condition).empty();
      $(this.dom.conditionTitle).attr('selected', true).attr('disabled', true);
      $(this.dom.condition).prepend(this.dom.conditionTitle).prop('selectedIndex', 0);
      this.s.conditions = {};
      this.s.condition = undefined;
    };
    /**
     * Clears the value elements
     */
    Criteria.prototype._clearValue = function () {
      if (this.s.condition !== undefined) {
        // Remove all of the value elements
        for (var _i = 0, _a = this.dom.value; _i < _a.length; _i++) {
          var val = _a[_i];
          $(val).remove();
        }
        // Call the init function to get the value elements for this condition
        this.dom.value = [].concat(this.s.conditions[this.s.condition].init(this, Criteria.updateListener));
        $(this.dom.value[0]).insertAfter(this.dom.condition).trigger('dtsb-inserted');
        // Insert all of the value elements
        for (var i = 1; i < this.dom.value.length; i++) {
          $(this.dom.value[i]).insertAfter(this.dom.value[i - 1]).trigger('dtsb-inserted');
        }
      } else {
        // Remove all of the value elements
        for (var _b = 0, _c = this.dom.value; _b < _c.length; _b++) {
          var val = _c[_b];
          $(val).remove();
        }
        // Append the default valueTitle to the default select element
        $(this.dom.valueTitle)
          .attr('selected', true);
        $(this.dom.defaultValue)
          .append(this.dom.valueTitle)
          .insertAfter(this.dom.condition);
      }
      this.s.value = [];
    };
    /**
     * Gets the options for the column
     * @returns {object} The options for the column
     */
    Criteria.prototype._getOptions = function () {
      var table = this.s.dt;
      return $.extend(true, {}, Criteria.defaults, table.settings()[0].aoColumns[this.s.dataIdx].searchBuilder);
    };
    /**
     * Populates the condition dropdown
     */
    Criteria.prototype._populateCondition = function () {
      var conditionOpts = [];
      var conditionsLength = Object.keys(this.s.conditions).length;
      // If there are no conditions stored then we need to get them from the appropriate type
      if (conditionsLength === 0) {
        var column = $(this.dom.data).children('option:selected').val();
        this.s.type = this.s.dt.columns().type().toArray()[column];
        // If the column type is unknown, call a draw to try reading it again
        if (this.s.type === null) {
          this.s.dt.draw();
          this.setListeners();
          this.s.type = this.s.dt.columns().type().toArray()[column];
        }
        // Enable the condition element
        $(this.dom.condition)
          .attr('disabled', false)
          .empty()
          .append(this.dom.conditionTitle)
          .addClass(this.classes.italic);
        $(this.dom.conditionTitle)
          .attr('selected', true);
        var decimal = this.s.dt.settings()[0].oLanguage.sDecimal;
        // This check is in place for if a custom decimal character is in place
        if (decimal !== '' && this.s.type.indexOf(decimal) === this.s.type.length - decimal.length) {
          if (this.s.type.indexOf('num-fmt') !== -1) {
            this.s.type = this.s.type.replace(decimal, '');
          } else if (this.s.type.indexOf('num') !== -1) {
            this.s.type = this.s.type.replace(decimal, '');
          }
        }
        // Select which conditions are going to be used based on the column type
        var conditionObj = this.c.conditions[this.s.type] !== undefined ?
          this.c.conditions[this.s.type] :
          this.s.type.indexOf('moment') !== -1 ?
            this.c.conditions.moment :
            this.c.conditions.string;
        // If it is a moment format then extract the date format
        if (this.s.type.indexOf('moment') !== -1) {
          this.s.momentFormat = this.s.type.replace(/moment\-/g, '');
        }
        // Add all of the conditions to the select element
        for (var _i = 0, _a = Object.keys(conditionObj); _i < _a.length; _i++) {
          var condition = _a[_i];
          if (conditionObj[condition] !== null) {
            this.s.conditions[condition] = conditionObj[condition];
            var condName = conditionObj[condition].conditionName;
            if (typeof condName === 'function') {
              condName = condName(this.s.dt, this.c.i18n);
            }
            conditionOpts.push($('<option>', {
              text: condName,
              value: condition
            })
              .addClass(this.classes.option)
              .addClass(this.classes.notItalic));
          }
        }
      }
      // Otherwise we can just load them in
      else if (conditionsLength > 0) {
        $(this.dom.condition).empty().attr('disabled', false).addClass(this.classes.italic);
        for (var _b = 0, _c = Object.keys(this.s.conditions); _b < _c.length; _b++) {
          var condition = _c[_b];
          var condName = this.s.conditions[condition].conditionName;
          if (typeof condName === 'function') {
            condName = condName(this.s.dt, this.c.i18n);
          }
          var newOpt = $('<option>', {
            text: condName,
            value: condition
          })
            .addClass(this.classes.option)
            .addClass(this.classes.notItalic);
          if (this.s.condition !== undefined && this.s.condition === condName) {
            $(newOpt).attr('selected', true);
            $(this.dom.condition).removeClass(this.classes.italic);
          }
          conditionOpts.push(newOpt);
        }
      } else {
        $(this.dom.condition)
          .attr('disabled', true)
          .addClass(this.classes.italic);
        return;
      }
      for (var _d = 0, conditionOpts_1 = conditionOpts; _d < conditionOpts_1.length; _d++) {
        var opt = conditionOpts_1[_d];
        $(this.dom.condition).append(opt);
      }
      $(this.dom.condition).prop('selectedIndex', 0);
    };
    /**
     * Populates the data select element
     */
    Criteria.prototype._populateData = function () {
      var _this = this;
      $(this.dom.data).empty().append(this.dom.dataTitle);
      // If there are no datas stored then we need to get them from the table
      if (this.s.dataPoints.length === 0) {
        this.s.dt.columns().every(function (index) {
          // Need to check that the column can be filtered on before adding it
          if (_this.c.columns === true ||
            (_this.s.dt.columns(_this.c.columns).indexes().toArray().indexOf(index) !== -1)) {
            var found = false;
            for (var _i = 0, _a = _this.s.dataPoints; _i < _a.length; _i++) {
              var val = _a[_i];
              if (val.index === index) {
                found = true;
                break;
              }
            }
            if (!found) {
              var opt = {text: _this.s.dt.settings()[0].aoColumns[index].sTitle, index: index};
              _this.s.dataPoints.push(opt);
              $(_this.dom.data).append($('<option>', {
                text: opt.text,
                value: opt.index
              })
                .addClass(_this.classes.option)
                .addClass(_this.classes.notItalic));
            }
          }
        });
      }
      // Otherwise we can just load them in
      else {
        var _loop_1 = function (data) {
          this_1.s.dt.columns().every(function (index) {
            if (_this.s.dt.settings()[0].aoColumns[index].sTitle === data.text) {
              data.index = index;
            }
          });
          var newOpt = $('<option>', {
            text: data.text,
            value: data.index
          })
            .addClass(this_1.classes.option)
            .addClass(this_1.classes.notItalic);
          if (this_1.s.data === data.text) {
            this_1.s.dataIdx = data.index;
            $(newOpt).attr('selected', true);
            $(this_1.dom.data).removeClass(this_1.classes.italic);
          }
          $(this_1.dom.data).append(newOpt);
        };
        var this_1 = this;
        for (var _i = 0, _a = this.s.dataPoints; _i < _a.length; _i++) {
          var data = _a[_i];
          _loop_1(data);
        }
      }
    };
    /**
     * Populates the Value select element
     * @param loadedCriteria optional, used to reload criteria from predefined filters
     */
    Criteria.prototype._populateValue = function (loadedCriteria) {
      var _this = this;
      var prevFilled = this.s.filled;
      this.s.filled = false;
      // Remove any previous value elements
      $(this.dom.defaultValue).remove();
      for (var _i = 0, _a = this.dom.value; _i < _a.length; _i++) {
        var val = _a[_i];
        $(val).remove();
      }
      var children = $(this.dom.container).children();
      if (children.length > 3) {
        for (var i = 2; i < children.length - 1; i++) {
          $(children[i]).remove();
        }
      }
      // Find the column with the title matching the data for the criteria and take note of the index
      if (loadedCriteria !== undefined) {
        this.s.dt.columns().every(function (index) {
          if (_this.s.dt.settings()[0].aoColumns[index].sTitle === loadedCriteria.data) {
            _this.s.dataIdx = index;
          }
        });
      }
      // Initialise the value elements based on the condition
      this.dom.value = [].concat(this.s.conditions[this.s.condition].init(this, Criteria.updateListener, loadedCriteria !== undefined ? loadedCriteria.value : undefined));
      if (loadedCriteria !== undefined && loadedCriteria.value !== undefined) {
        this.s.value = loadedCriteria.value;
      }
      // Insert value elements and trigger the inserted event
      $(this.dom.value[0])
        .insertAfter(this.dom.condition)
        .trigger('dtsb-inserted');
      for (var i = 1; i < this.dom.value.length; i++) {
        $(this.dom.value[i])
          .insertAfter(this.dom.value[i - 1])
          .trigger('dtsb-inserted');
      }
      // Check if the criteria can be used in a search
      this.s.filled = this.s.conditions[this.s.condition].isInputValid(this.dom.value, this);
      this.setListeners();
      // If it can and this is different to before then trigger a draw
      if (prevFilled !== this.s.filled) {
        this.s.dt.draw();
        this.setListeners();
      }
    };
    Criteria.version = '1.0.0';
    Criteria.classes = {
      button: 'dtsb-button',
      buttonContainer: 'dtsb-buttonContainer',
      condition: 'dtsb-condition',
      container: 'dtsb-criteria',
      data: 'dtsb-data',
      "delete": 'dtsb-delete',
      dropDown: 'dtsb-dropDown',
      greyscale: 'dtsb-greyscale',
      input: 'dtsb-input',
      italic: 'dtsb-italic',
      joiner: 'dtsp-joiner',
      left: 'dtsb-left',
      notItalic: 'dtsb-notItalic',
      option: 'dtsb-option',
      right: 'dtsb-right',
      value: 'dtsb-value',
      vertical: 'dtsb-vertical'
    };
    /**
     * Default initialisation function for select conditions
     */
    Criteria.initSelect = function (that, fn, preDefined, array) {
      if (preDefined === void 0) {
        preDefined = null;
      }
      if (array === void 0) {
        array = false;
      }
      var column = $(that.dom.data).children('option:selected').val();
      var indexArray = that.s.dt.rows().indexes().toArray();
      var settings = that.s.dt.settings()[0];
      // Declare select element to be used with all of the default classes and listeners.
      var el = $('<select/>')
        .addClass(Criteria.classes.value)
        .addClass(Criteria.classes.dropDown)
        .addClass(Criteria.classes.italic)
        .append(that.dom.valueTitle)
        .on('input change', function () {
          $(this).removeClass(Criteria.classes.italic);
          fn(that, this);
        });
      if (that.c.greyscale) {
        $(el).addClass(Criteria.classes.greyscale);
      }
      var added = [];
      var options = [];
      // Add all of the options from the table to the select element.
      // Only add one option for each possible value
      for (var _i = 0, indexArray_1 = indexArray; _i < indexArray_1.length; _i++) {
        var index = indexArray_1[_i];
        var filter = settings.oApi._fnGetCellData(settings, index, column, typeof that.c.orthogonal === 'string' ?
          that.c.orthogonal :
          that.c.orthogonal.search);
        var value = {
          filter: typeof filter === 'string' ?
            filter.replace(/[\r\n\u2028]/g, ' ') : // Need to replace certain characters to match the search values
            filter,
          index: index,
          text: settings.oApi._fnGetCellData(settings, index, column, typeof that.c.orthogonal === 'string' ?
            that.c.orthogonal :
            that.c.orthogonal.display)
        };
        // If we are dealing with an array type, either make sure we are working with arrays, or sort them
        if (that.s.type === 'array') {
          value.filter = !Array.isArray(value.filter) ?
            [value.filter] :
            value.filter = value.filter.sort();
          value.text = !Array.isArray(value.text) ?
            [value.text] :
            value.text = value.text.sort();
        }
        // Function to add an option to the select element
        var addOption = function (filt, text) {
          // Add text and value, stripping out any html if that is the column type
          var opt = $('<option>', {
            text: typeof text === 'string' ?
              text.replace(/(<([^>]+)>)/ig, '') :
              text,
            type: Array.isArray(filt) ? 'Array' : 'String',
            value: that.s.type.indexOf('html') !== -1 && filt !== null && typeof filt === 'string' ?
              filt.replace(/(<([^>]+)>)/ig, '') :
              filt
          })
            .addClass(that.classes.option)
            .addClass(that.classes.notItalic);
          var val = $(opt).val();
          // Check that this value has not already been added
          if (added.indexOf(val) === -1) {
            added.push(val);
            options.push(opt);
            if (preDefined !== null && Array.isArray(preDefined[0])) {
              preDefined[0] = preDefined[0].sort().join(',');
            }
            // If this value was previously selected as indicated by preDefined, then select it again
            if (preDefined !== null && opt.val() === preDefined[0]) {
              opt.attr('selected', true);
              $(el).removeClass(Criteria.classes.italic);
            }
          }
        };
        // If this is to add the individual values within the array we need to loop over the array
        if (array) {
          for (var i = 0; i < value.filter.length; i++) {
            addOption(value.filter[i], value.text[i]);
          }
        }
        // Otherwise the value that is in the cell is to be added
        else {
          addOption(value.filter, value.text);
        }
      }
      options.sort(function (a, b) {
        if (that.s.type === 'string' || that.s.type === 'num' || that.s.type === 'html' || that.s.type === 'html-num') {
          if ($(a).val() < $(b).val()) {
            return -1;
          } else if ($(a).val() < $(b).val()) {
            return 1;
          } else {
            return 0;
          }
        } else if (that.s.type === 'num-fmt' || that.s.type === 'html-num-fmt') {
          if (+$(a).val().replace(/[^0-9.]/g, '') < +$(b).val().replace(/[^0-9.]/g, '')) {
            return -1;
          } else if (+$(a).val().replace(/[^0-9.]/g, '') < +$(b).val().replace(/[^0-9.]/g, '')) {
            return 1;
          } else {
            return 0;
          }
        }
      });
      for (var _a = 0, options_1 = options; _a < options_1.length; _a++) {
        var opt = options_1[_a];
        $(el).append(opt);
      }
      return el;
    };
    /**
     * Default initialisation function for select array conditions
     *
     * This exists because there needs to be different select functionality for contains/without and equals/not
     */
    Criteria.initSelectArray = function (that, fn, preDefined) {
      if (preDefined === void 0) {
        preDefined = null;
      }
      return Criteria.initSelect(that, fn, preDefined, true);
    };
    /**
     * Default initialisation function for input conditions
     */
    Criteria.initInput = function (that, fn, preDefined) {
      if (preDefined === void 0) {
        preDefined = null;
      }
      // Declare the input element
      var el = $('<input/>')
        .addClass(Criteria.classes.value)
        .addClass(Criteria.classes.input)
        .on('input', function () {
          fn(that, this);
        });
      if (that.c.greyscale) {
        $(el).addClass(Criteria.classes.greyscale);
      }
      // If there is a preDefined value then add it
      if (preDefined !== null) {
        $(el).val(preDefined[0]);
      }
      return el;
    };
    /**
     * Default initialisation function for conditions requiring 2 inputs
     */
    Criteria.init2Input = function (that, fn, preDefined) {
      if (preDefined === void 0) {
        preDefined = null;
      }
      // Declare all of the necessary jQuery elements
      var els = [
        $('<input/>')
          .addClass(Criteria.classes.value)
          .addClass(Criteria.classes.input)
          .on('input', function () {
            fn(that, this);
          }),
        $('<span>')
          .addClass(that.classes.joiner).text(that.s.dt.i18n('searchBuilder.valueJoiner', that.c.i18n.valueJoiner)),
        $('<input/>')
          .addClass(Criteria.classes.value)
          .addClass(Criteria.classes.input)
          .on('input', function () {
            fn(that, this);
          })
      ];
      if (that.c.greyscale) {
        $(els[0]).addClass(Criteria.classes.greyscale);
        $(els[2]).addClass(Criteria.classes.greyscale);
      }
      // If there is a preDefined value then add it
      if (preDefined !== null) {
        $(els[0]).val(preDefined[0]);
        $(els[2]).val(preDefined[1]);
      }
      that.s.dt.off('draw');
      that.s.dt.one('draw', function () {
        $(that.s.topGroup).trigger('dtsb-redrawContents');
      });
      return els;
    };
    /**
     * Default initialisation function for date conditions
     */
    Criteria.initDate = function (that, fn, preDefined) {
      if (preDefined === void 0) {
        preDefined = null;
      }
      // Declare date element using DataTables dateTime plugin
      var el = $('<input/>')
        .addClass(Criteria.classes.value)
        .addClass(Criteria.classes.input)
        .dtDateTime({
          attachTo: 'input',
          format: that.s.momentFormat ? that.s.momentFormat : undefined
        })
        .on('input change', function () {
          fn(that, this);
        });
      if (that.c.greyscale) {
        $(el).addClass(Criteria.classes.greyscale);
      }
      // If there is a preDefined value then add it
      if (preDefined !== null) {
        $(el).val(preDefined[0]);
      }
      return el;
    };
    Criteria.initNoValue = function (that) {
      that.s.dt.off('draw');
      that.s.dt.one('draw', function () {
        $(that.s.topGroup).trigger('dtsb-redrawContents');
      });
    };
    Criteria.init2Date = function (that, fn, preDefined) {
      if (preDefined === void 0) {
        preDefined = null;
      }
      // Declare all of the date elements that are required using DataTables dateTime plugin
      var els = [
        $('<input/>')
          .addClass(Criteria.classes.value)
          .addClass(Criteria.classes.input)
          .dtDateTime({
            attachTo: 'input',
            format: that.s.momentFormat ? that.s.momentFormat : undefined
          })
          .on('input change', function () {
            fn(that, this);
          }),
        $('<span>')
          .addClass(that.classes.joiner)
          .text(that.s.dt.i18n('searchBuilder.valueJoiner', that.c.i18n.valueJoiner)),
        $('<input/>')
          .addClass(Criteria.classes.value)
          .addClass(Criteria.classes.input)
          .dtDateTime({
            attachTo: 'input',
            format: that.s.momentFormat ? that.s.momentFormat : undefined
          })
          .on('input change', function () {
            fn(that, this);
          })
      ];
      if (that.c.greyscale) {
        $(els[0]).addClass(Criteria.classes.greyscale);
        $(els[2]).addClass(Criteria.classes.greyscale);
      }
      // If there are and preDefined values then add them
      if (preDefined !== null && preDefined.length > 0) {
        $(els[0]).val(preDefined[0]);
        $(els[2]).val(preDefined[1]);
      }
      that.s.dt.off('draw');
      that.s.dt.one('draw', function () {
        $(that.s.topGroup).trigger('dtsb-redrawContents');
      });
      return els;
    };
    /**
     * Default function for select elements to validate condition
     */
    Criteria.isInputValidSelect = function (el) {
      var allFilled = true;
      // Check each element to make sure that the selections are valid
      for (var _i = 0, el_1 = el; _i < el_1.length; _i++) {
        var element = el_1[_i];
        if ($(element).children('option:selected').length === $(element).children('option').length - $(element).children('option.' + Criteria.classes.notItalic).length &&
          $(element).children('option:selected').length === 1 &&
          $(element).children('option:selected')[0] === $(element).children('option:hidden')[0]) {
          allFilled = false;
        }
      }
      return allFilled;
    };
    /**
     * Default function for input and date elements to validate condition
     */
    Criteria.isInputValidInput = function (el) {
      var allFilled = true;
      // Check each element to make sure that the inputs are valid
      for (var _i = 0, el_2 = el; _i < el_2.length; _i++) {
        var element = el_2[_i];
        if ($(element).is('input') && $(element).val().length === 0) {
          allFilled = false;
        }
      }
      return allFilled;
    };
    /**
     * Default function for getting select conditions
     */
    Criteria.inputValueSelect = function (el) {
      var values = [];
      // Go through the select elements and push each selected option to the return array
      for (var _i = 0, el_3 = el; _i < el_3.length; _i++) {
        var element = el_3[_i];
        if ($(element).is('select')) {
          var val = $(element).children('option:selected').val();
          // If the type of the option is an array we need to split it up and sort it
          values.push($(element).children('option:selected').attr('type') === 'Array' ?
            val.split(',').sort() :
            val);
        }
      }
      return values;
    };
    /**
     * Default function for getting input conditions
     */
    Criteria.inputValueInput = function (el) {
      var values = [];
      // Go through the input elements and push each value to the return array
      for (var _i = 0, el_4 = el; _i < el_4.length; _i++) {
        var element = el_4[_i];
        if ($(element).is('input')) {
          values.push($(element).val());
        }
      }
      return values;
    };
    /**
     * Function that is run on each element as a call back when a search should be triggered
     */
    Criteria.updateListener = function (that, el) {
      // When the value is changed the criteria is now complete so can be included in searches
      // Get the condition from the map based on the key that has been selected for the condition
      var condition = that.s.conditions[that.s.condition];
      that.s.filled = condition.isInputValid(that.dom.value, that);
      that.s.value = condition.inputValue(that.dom.value, that);
      if (!Array.isArray(that.s.value)) {
        that.s.value = [that.s.value];
      }
      for (var i = 0; i < that.s.value.length; i++) {
        // If the value is an array we need to sort it
        if (Array.isArray(that.s.value[i])) {
          that.s.value[i].sort();
        }
        // Otherwise replace the decimal place character for i18n
        else if (that.s.dt.settings()[0].oLanguage.sDecimal !== '') {
          that.s.value[i] = that.s.value[i].replace(that.s.dt.settings()[0].oLanguage.sDecimal, '.');
        }
      }
      // Take note of the cursor position so that we can refocus there later
      var idx = null;
      var cursorPos = null;
      for (var i = 0; i < that.dom.value.length; i++) {
        if (el === that.dom.value[i][0]) {
          idx = i;
          if (el.selectionStart !== undefined) {
            cursorPos = el.selectionStart;
          }
        }
      }
      // Trigger a search
      that.s.dt.draw();
      // Refocus the element and set the correct cursor position
      if (idx !== null) {
        $(that.dom.value[idx]).removeClass(that.classes.italic);
        $(that.dom.value[idx]).focus();
        if (cursorPos !== null) {
          $(that.dom.value[idx])[0].setSelectionRange(cursorPos, cursorPos);
        }
      }
    };
    // The order of the conditions will make tslint sad :(
    Criteria.dateConditions = {
      '=': {
        conditionName: function (dt, i18n) {
          return dt.i18n('searchBuilder.conditions.date.equals', i18n.conditions.date.equals);
        },
        init: Criteria.initDate,
        inputValue: Criteria.inputValueInput,
        isInputValid: Criteria.isInputValidInput,
        search: function (value, comparison) {
          value = value.replace(/(\/|\-|\,)/g, '-');
          return value === comparison[0];
        }
      },
      '!=': {
        conditionName: function (dt, i18n) {
          return dt.i18n('searchBuilder.conditions.date.not', i18n.conditions.date.not);
        },
        init: Criteria.initDate,
        inputValue: Criteria.inputValueInput,
        isInputValid: Criteria.isInputValidInput,
        search: function (value, comparison) {
          value = value.replace(/(\/|\-|\,)/g, '-');
          return value !== comparison[0];
        }
      },
      '<': {
        conditionName: function (dt, i18n) {
          return dt.i18n('searchBuilder.conditions.date.before', i18n.conditions.date.before);
        },
        init: Criteria.initDate,
        inputValue: Criteria.inputValueInput,
        isInputValid: Criteria.isInputValidInput,
        search: function (value, comparison) {
          value = value.replace(/(\/|\-|\,)/g, '-');
          return value < comparison[0];
        }
      },
      '>': {
        conditionName: function (dt, i18n) {
          return dt.i18n('searchBuilder.conditions.date.after', i18n.conditions.date.after);
        },
        init: Criteria.initDate,
        inputValue: Criteria.inputValueInput,
        isInputValid: Criteria.isInputValidInput,
        search: function (value, comparison) {
          value = value.replace(/(\/|\-|\,)/g, '-');
          return value > comparison[0];
        }
      },
      'between': {
        conditionName: function (dt, i18n) {
          return dt.i18n('searchBuilder.conditions.date.between', i18n.conditions.date.between);
        },
        init: Criteria.init2Date,
        inputValue: Criteria.inputValueInput,
        isInputValid: Criteria.isInputValidInput,
        search: function (value, comparison) {
          value = value.replace(/(\/|\-|\,)/g, '-');
          if (comparison[0] < comparison[1]) {
            return comparison[0] <= value && value <= comparison[1];
          } else {
            return comparison[1] <= value && value <= comparison[0];
          }
        }
      },
      '!between': {
        conditionName: function (dt, i18n) {
          return dt.i18n('searchBuilder.conditions.date.notBetween', i18n.conditions.date.notBetween);
        },
        init: Criteria.init2Date,
        inputValue: Criteria.inputValueInput,
        isInputValid: Criteria.isInputValidInput,
        search: function (value, comparison) {
          value = value.replace(/(\/|\-|\,)/g, '-');
          if (comparison[0] < comparison[1]) {
            return !(comparison[0] <= value && value <= comparison[1]);
          } else {
            return !(comparison[1] <= value && value <= comparison[0]);
          }
        }
      },
      'null': {
        conditionName: function (dt, i18n) {
          return dt.i18n('searchBuilder.conditions.date.empty', i18n.conditions.date.empty);
        },
        isInputValid: function () {
          return true;
        },
        init: Criteria.initNoValue,
        inputValue: function () {
          return;
        },
        search: function (value) {
          return (value === null || value === undefined || value.length === 0);
        }
      },
      '!null': {
        conditionName: function (dt, i18n) {
          return dt.i18n('searchBuilder.conditions.date.notEmpty', i18n.conditions.date.notEmpty);
        },
        isInputValid: function () {
          return true;
        },
        init: Criteria.initNoValue,
        inputValue: function () {
          return;
        },
        search: function (value) {
          return !(value === null || value === undefined || value.length === 0);
        }
      }
    };
    // The order of the conditions will make tslint sad :(
    Criteria.momentDateConditions = {
      '=': {
        conditionName: function (dt, i18n) {
          return dt.i18n('searchBuilder.conditions.moment.equals', i18n.conditions.moment.equals);
        },
        init: Criteria.initDate,
        inputValue: Criteria.inputValueInput,
        isInputValid: Criteria.isInputValidInput,
        search: function (value, comparison, that) {
          return moment(value, that.s.momentFormat).valueOf() === moment(comparison[0], that.s.momentFormat).valueOf();
        }
      },
      '!=': {
        conditionName: function (dt, i18n) {
          return dt.i18n('searchBuilder.conditions.moment.not', i18n.conditions.moment.not);
        },
        init: Criteria.initDate,
        inputValue: Criteria.inputValueInput,
        isInputValid: Criteria.isInputValidInput,
        search: function (value, comparison, that) {
          return moment(value, that.s.momentFormat).valueOf() !== moment(comparison[0], that.s.momentFormat).valueOf();
        }
      },
      '<': {
        conditionName: function (dt, i18n) {
          return dt.i18n('searchBuilder.conditions.moment.before', i18n.conditions.moment.before);
        },
        init: Criteria.initDate,
        inputValue: Criteria.inputValueInput,
        isInputValid: Criteria.isInputValidInput,
        search: function (value, comparison, that) {
          return moment(value, that.s.momentFormat).valueOf() < moment(comparison[0], that.s.momentFormat).valueOf();
        }
      },
      '>': {
        conditionName: function (dt, i18n) {
          return dt.i18n('searchBuilder.conditions.moment.after', i18n.conditions.moment.after);
        },
        init: Criteria.initDate,
        inputValue: Criteria.inputValueInput,
        isInputValid: Criteria.isInputValidInput,
        search: function (value, comparison, that) {
          return moment(value, that.s.momentFormat).valueOf() > moment(comparison[0], that.s.momentFormat).valueOf();
        }
      },
      'between': {
        conditionName: function (dt, i18n) {
          return dt.i18n('searchBuilder.conditions.moment.between', i18n.conditions.moment.between);
        },
        init: Criteria.init2Date,
        inputValue: Criteria.inputValueInput,
        isInputValid: Criteria.isInputValidInput,
        search: function (value, comparison, that) {
          var val = moment(value, that.s.momentFormat).valueOf();
          var comp0 = moment(comparison[0], that.s.momentFormat).valueOf();
          var comp1 = moment(comparison[1], that.s.momentFormat).valueOf();
          if (comp0 < comp1) {
            return comp0 <= val && val <= comp1;
          } else {
            return comp1 <= val && val <= comp0;
          }
        }
      },
      '!between': {
        conditionName: function (dt, i18n) {
          return dt.i18n('searchBuilder.conditions.moment.notBetween', i18n.conditions.moment.notBetween);
        },
        init: Criteria.init2Date,
        inputValue: Criteria.inputValueInput,
        isInputValid: Criteria.isInputValidInput,
        search: function (value, comparison, that) {
          var val = moment(value, that.s.momentFormat).valueOf();
          var comp0 = moment(comparison[0], that.s.momentFormat).valueOf();
          var comp1 = moment(comparison[1], that.s.momentFormat).valueOf();
          if (comp0 < comp1) {
            return !(+comp0 <= +val && +val <= +comp1);
          } else {
            return !(+comp1 <= +val && +val <= +comp0);
          }
        }
      },
      'null': {
        conditionName: function (dt, i18n) {
          return dt.i18n('searchBuilder.conditions.moment.empty', i18n.conditions.moment.empty);
        },
        isInputValid: function () {
          return true;
        },
        init: Criteria.initNoValue,
        inputValue: function () {
          return;
        },
        search: function (value) {
          return (value === null || value === undefined || value.length === 0);
        }
      },
      '!null': {
        conditionName: function (dt, i18n) {
          return dt.i18n('searchBuilder.conditions.moment.notEmpty', i18n.conditions.moment.notEmpty);
        },
        isInputValid: function () {
          return true;
        },
        init: Criteria.initNoValue,
        inputValue: function () {
          return;
        },
        search: function (value) {
          return !(value === null || value === undefined || value.length === 0);
        }
      }
    };
    // The order of the conditions will make tslint sad :(
    Criteria.numConditions = {
      '=': {
        conditionName: function (dt, i18n) {
          return dt.i18n('searchBuilder.conditions.number.equals', i18n.conditions.number.equals);
        },
        init: Criteria.initSelect,
        inputValue: Criteria.inputValueSelect,
        isInputValid: Criteria.isInputValidSelect,
        search: function (value, comparison) {
          return +value === +comparison[0];
        }
      },
      '!=': {
        conditionName: function (dt, i18n) {
          return dt.i18n('searchBuilder.conditions.number.not', i18n.conditions.number.not);
        },
        init: Criteria.initSelect,
        inputValue: Criteria.inputValueSelect,
        isInputValid: Criteria.isInputValidSelect,
        search: function (value, comparison) {
          return +value !== +comparison[0];
        }
      },
      '<': {
        conditionName: function (dt, i18n) {
          return dt.i18n('searchBuilder.conditions.number.lt', i18n.conditions.number.lt);
        },
        init: Criteria.initInput,
        inputValue: Criteria.inputValueInput,
        isInputValid: Criteria.isInputValidInput,
        search: function (value, comparison) {
          return +value < +comparison[0];
        }
      },
      '<=': {
        conditionName: function (dt, i18n) {
          return dt.i18n('searchBuilder.conditions.number.lte', i18n.conditions.number.lte);
        },
        init: Criteria.initInput,
        inputValue: Criteria.inputValueInput,
        isInputValid: Criteria.isInputValidInput,
        search: function (value, comparison) {
          return +value <= +comparison[0];
        }
      },
      '>=': {
        conditionName: function (dt, i18n) {
          return dt.i18n('searchBuilder.conditions.number.gte', i18n.conditions.number.gte);
        },
        init: Criteria.initInput,
        inputValue: Criteria.inputValueInput,
        isInputValid: Criteria.isInputValidInput,
        search: function (value, comparison) {
          return +value >= +comparison[0];
        }
      },
      '>': {
        conditionName: function (dt, i18n) {
          return dt.i18n('searchBuilder.conditions.number.gt', i18n.conditions.number.gt);
        },
        init: Criteria.initInput,
        inputValue: Criteria.inputValueInput,
        isInputValid: Criteria.isInputValidInput,
        search: function (value, comparison) {
          return +value > +comparison[0];
        }
      },
      'between': {
        conditionName: function (dt, i18n) {
          return dt.i18n('searchBuilder.conditions.number.between', i18n.conditions.number.between);
        },
        init: Criteria.init2Input,
        inputValue: Criteria.inputValueInput,
        isInputValid: Criteria.isInputValidInput,
        search: function (value, comparison) {
          if (+comparison[0] < +comparison[1]) {
            return +comparison[0] <= +value && +value <= +comparison[1];
          } else {
            return +comparison[1] <= +value && +value <= +comparison[0];
          }
        }
      },
      '!between': {
        conditionName: function (dt, i18n) {
          return dt.i18n('searchBuilder.conditions.number.notBetween', i18n.conditions.number.notBetween);
        },
        init: Criteria.init2Input,
        inputValue: Criteria.inputValueInput,
        isInputValid: Criteria.isInputValidInput,
        search: function (value, comparison) {
          if (+comparison[0] < +comparison[1]) {
            return !(+comparison[0] <= +value && +value <= +comparison[1]);
          } else {
            return !(+comparison[1] <= +value && +value <= +comparison[0]);
          }
        }
      },
      'null': {
        conditionName: function (dt, i18n) {
          return dt.i18n('searchBuilder.conditions.number.empty', i18n.conditions.number.empty);
        },
        init: Criteria.initNoValue,
        inputValue: function () {
          return;
        },
        isInputValid: function () {
          return true;
        },
        search: function (value) {
          return (value === null || value === undefined || value.length === 0);
        }
      },
      '!null': {
        conditionName: function (dt, i18n) {
          return dt.i18n('searchBuilder.conditions.number.notEmpty', i18n.conditions.number.notEmpty);
        },
        isInputValid: function () {
          return true;
        },
        init: Criteria.initNoValue,
        inputValue: function () {
          return;
        },
        search: function (value) {
          return !(value === null || value === undefined || value.length === 0);
        }
      }
    };
    // The order of the conditions will make tslint sad :(
    Criteria.numFmtConditions = {
      '=': {
        conditionName: function (dt, i18n) {
          return dt.i18n('searchBuilder.conditions.number.equals', i18n.conditions.number.equals);
        },
        init: Criteria.initSelect,
        inputValue: Criteria.inputValueSelect,
        isInputValid: Criteria.isInputValidSelect,
        search: function (value, comparison) {
          var val = value.indexOf('-') === 0 ?
            '-' + value.replace(/[^0-9.]/g, '') :
            value.replace(/[^0-9.]/g, '');
          var comp = comparison[0].indexOf('-') === 0 ?
            '-' + comparison[0].replace(/[^0-9.]/g, '') :
            comparison[0].replace(/[^0-9.]/g, '');
          return +val === +comp;
        }
      },
      '!=': {
        conditionName: function (dt, i18n) {
          return dt.i18n('searchBuilder.conditions.number.not', i18n.conditions.number.not);
        },
        init: Criteria.initSelect,
        inputValue: Criteria.inputValueSelect,
        isInputValid: Criteria.isInputValidSelect,
        search: function (value, comparison) {
          var val = value.indexOf('-') === 0 ?
            '-' + value.replace(/[^0-9.]/g, '') :
            value.replace(/[^0-9.]/g, '');
          var comp = comparison[0].indexOf('-') === 0 ?
            '-' + comparison[0].replace(/[^0-9.]/g, '') :
            comparison[0].replace(/[^0-9.]/g, '');
          return +val !== +comp;
        }
      },
      '<': {
        conditionName: function (dt, i18n) {
          return dt.i18n('searchBuilder.conditions.number.lt', i18n.conditions.number.lt);
        },
        init: Criteria.initInput,
        inputValue: Criteria.inputValueInput,
        isInputValid: Criteria.isInputValidInput,
        search: function (value, comparison) {
          var val = value.indexOf('-') === 0 ?
            '-' + value.replace(/[^0-9.]/g, '') :
            value.replace(/[^0-9.]/g, '');
          var comp = comparison[0].indexOf('-') === 0 ?
            '-' + comparison[0].replace(/[^0-9.]/g, '') :
            comparison[0].replace(/[^0-9.]/g, '');
          return +val < +comp;
        }
      },
      '<=': {
        conditionName: function (dt, i18n) {
          return dt.i18n('searchBuilder.conditions.number.lte', i18n.conditions.number.lte);
        },
        init: Criteria.initInput,
        inputValue: Criteria.inputValueInput,
        isInputValid: Criteria.isInputValidInput,
        search: function (value, comparison) {
          var val = value.indexOf('-') === 0 ?
            '-' + value.replace(/[^0-9.]/g, '') :
            value.replace(/[^0-9.]/g, '');
          var comp = comparison[0].indexOf('-') === 0 ?
            '-' + comparison[0].replace(/[^0-9.]/g, '') :
            comparison[0].replace(/[^0-9.]/g, '');
          return +val <= +comp;
        }
      },
      '>=': {
        conditionName: function (dt, i18n) {
          return dt.i18n('searchBuilder.conditions.number.gte', i18n.conditions.number.gte);
        },
        init: Criteria.initInput,
        inputValue: Criteria.inputValueInput,
        isInputValid: Criteria.isInputValidInput,
        search: function (value, comparison) {
          var val = value.indexOf('-') === 0 ?
            '-' + value.replace(/[^0-9.]/g, '') :
            value.replace(/[^0-9.]/g, '');
          var comp = comparison[0].indexOf('-') === 0 ?
            '-' + comparison[0].replace(/[^0-9.]/g, '') :
            comparison[0].replace(/[^0-9.]/g, '');
          return +val >= +comp;
        }
      },
      '>': {
        conditionName: function (dt, i18n) {
          return dt.i18n('searchBuilder.conditions.number.gt', i18n.conditions.number.gt);
        },
        init: Criteria.initInput,
        inputValue: Criteria.inputValueInput,
        isInputValid: Criteria.isInputValidInput,
        search: function (value, comparison) {
          var val = value.indexOf('-') === 0 ?
            '-' + value.replace(/[^0-9.]/g, '') :
            value.replace(/[^0-9.]/g, '');
          var comp = comparison[0].indexOf('-') === 0 ?
            '-' + comparison[0].replace(/[^0-9.]/g, '') :
            comparison[0].replace(/[^0-9.]/g, '');
          return +val > +comp;
        }
      },
      'between': {
        conditionName: function (dt, i18n) {
          return dt.i18n('searchBuilder.conditions.number.between', i18n.conditions.number.between);
        },
        init: Criteria.init2Input,
        inputValue: Criteria.inputValueInput,
        isInputValid: Criteria.isInputValidInput,
        search: function (value, comparison) {
          var val = value.indexOf('-') === 0 ?
            '-' + value.replace(/[^0-9.]/g, '') :
            value.replace(/[^0-9.]/g, '');
          var comp0 = comparison[0].indexOf('-') === 0 ?
            '-' + comparison[0].replace(/[^0-9.]/g, '') :
            comparison[0].replace(/[^0-9.]/g, '');
          var comp1 = comparison[1].indexOf('-') === 0 ?
            '-' + comparison[1].replace(/[^0-9.]/g, '') :
            comparison[1].replace(/[^0-9.]/g, '');
          if (+comp0 < +comp1) {
            return +comp0 <= +val && +val <= +comp1;
          } else {
            return +comp1 <= +val && +val <= +comp0;
          }
        }
      },
      '!between': {
        conditionName: function (dt, i18n) {
          return dt.i18n('searchBuilder.conditions.number.notBetween', i18n.conditions.number.notBetween);
        },
        init: Criteria.init2Input,
        inputValue: Criteria.inputValueInput,
        isInputValid: Criteria.isInputValidInput,
        search: function (value, comparison) {
          var val = value.indexOf('-') === 0 ?
            '-' + value.replace(/[^0-9.]/g, '') :
            value.replace(/[^0-9.]/g, '');
          var comp0 = comparison[0].indexOf('-') === 0 ?
            '-' + comparison[0].replace(/[^0-9.]/g, '') :
            comparison[0].replace(/[^0-9.]/g, '');
          var comp1 = comparison[1].indexOf('-') === 0 ?
            '-' + comparison[1].replace(/[^0-9.]/g, '') :
            comparison[1].replace(/[^0-9.]/g, '');
          if (+comp0 < +comp1) {
            return !(+comp0 <= +val && +val <= +comp1);
          } else {
            return !(+comp1 <= +val && +val <= +comp0);
          }
        }
      },
      'null': {
        conditionName: function (dt, i18n) {
          return dt.i18n('searchBuilder.conditions.number.empty', i18n.conditions.number.empty);
        },
        init: Criteria.initNoValue,
        inputValue: function () {
          return;
        },
        isInputValid: function () {
          return true;
        },
        search: function (value) {
          return (value === null || value === undefined || value.length === 0);
        }
      },
      '!null': {
        conditionName: function (dt, i18n) {
          return dt.i18n('searchBuilder.conditions.number.notEmpty', i18n.conditions.number.notEmpty);
        },
        isInputValid: function () {
          return true;
        },
        init: Criteria.initNoValue,
        inputValue: function () {
          return;
        },
        search: function (value) {
          return !(value === null || value === undefined || value.length === 0);
        }
      }
    };
    // The order of the conditions will make tslint sad :(
    Criteria.stringConditions = {
      '=': {
        conditionName: function (dt, i18n) {
          return dt.i18n('searchBuilder.conditions.string.equals', i18n.conditions.string.equals);
        },
        init: Criteria.initSelect,
        inputValue: Criteria.inputValueSelect,
        isInputValid: Criteria.isInputValidSelect,
        search: function (value, comparison) {
          return value === comparison[0];
        }
      },
      '!=': {
        conditionName: function (dt, i18n) {
          return dt.i18n('searchBuilder.conditions.string.not', i18n.conditions.string.not);
        },
        init: Criteria.initSelect,
        inputValue: Criteria.inputValueSelect,
        isInputValid: Criteria.isInputValidInput,
        search: function (value, comparison) {
          return value !== comparison[0];
        }
      },
      'starts': {
        conditionName: function (dt, i18n) {
          return dt.i18n('searchBuilder.conditions.string.startsWith', i18n.conditions.string.startsWith);
        },
        init: Criteria.initInput,
        inputValue: Criteria.inputValueInput,
        isInputValid: Criteria.isInputValidInput,
        search: function (value, comparison) {
          return value.toLowerCase().indexOf(comparison[0].toLowerCase()) === 0;
        }
      },
      'contains': {
        conditionName: function (dt, i18n) {
          return dt.i18n('searchBuilder.conditions.string.contains', i18n.conditions.string.contains);
        },
        init: Criteria.initInput,
        inputValue: Criteria.inputValueInput,
        isInputValid: Criteria.isInputValidInput,
        search: function (value, comparison) {
          return value.toLowerCase().indexOf(comparison[0].toLowerCase()) !== -1;
        }
      },
      'ends': {
        conditionName: function (dt, i18n) {
          return dt.i18n('searchBuilder.conditions.string.endsWith', i18n.conditions.string.endsWith);
        },
        init: Criteria.initInput,
        inputValue: Criteria.inputValueInput,
        isInputValid: Criteria.isInputValidInput,
        search: function (value, comparison) {
          return value.toLowerCase().endsWith(comparison[0].toLowerCase());
        }
      },
      'null': {
        conditionName: function (dt, i18n) {
          return dt.i18n('searchBuilder.conditions.string.empty', i18n.conditions.string.empty);
        },
        init: Criteria.initNoValue,
        inputValue: function () {
          return;
        },
        isInputValid: function () {
          return true;
        },
        search: function (value) {
          return (value === null || value === undefined || value.length === 0);
        }
      },
      '!null': {
        conditionName: function (dt, i18n) {
          return dt.i18n('searchBuilder.conditions.string.notEmpty', i18n.conditions.string.notEmpty);
        },
        isInputValid: function () {
          return true;
        },
        init: Criteria.initNoValue,
        inputValue: function () {
          return;
        },
        search: function (value) {
          return !(value === null || value === undefined || value.length === 0);
        }
      }
    };
    // The order of the conditions will make tslint sad :(
    Criteria.arrayConditions = {
      'contains': {
        conditionName: function (dt, i18n) {
          return dt.i18n('searchBuilder.conditions.array.contains', i18n.conditions.array.contains);
        },
        init: Criteria.initSelectArray,
        inputValue: Criteria.inputValueSelect,
        isInputValid: Criteria.isInputValidSelect,
        search: function (value, comparison) {
          return value.indexOf(comparison[0]) !== -1;
        }
      },
      'without': {
        conditionName: function (dt, i18n) {
          return dt.i18n('searchBuilder.conditions.array.without', i18n.conditions.array.without);
        },
        init: Criteria.initSelectArray,
        inputValue: Criteria.inputValueSelect,
        isInputValid: Criteria.isInputValidSelect,
        search: function (value, comparison) {
          return value.indexOf(comparison[0]) === -1;
        }
      },
      '=': {
        conditionName: function (dt, i18n) {
          return dt.i18n('searchBuilder.conditions.array.equals', i18n.conditions.array.equals);
        },
        init: Criteria.initSelect,
        inputValue: Criteria.inputValueSelect,
        isInputValid: Criteria.isInputValidSelect,
        search: function (value, comparison) {
          if (value.length === comparison[0].length) {
            for (var i = 0; i < value.length; i++) {
              if (value[i] !== comparison[0][i]) {
                return false;
              }
            }
            return true;
          }
          return false;
        }
      },
      '!=': {
        conditionName: function (dt, i18n) {
          return dt.i18n('searchBuilder.conditions.array.not', i18n.conditions.array.not);
        },
        init: Criteria.initSelect,
        inputValue: Criteria.inputValueSelect,
        isInputValid: Criteria.isInputValidSelect,
        search: function (value, comparison) {
          if (value.length === comparison[0].length) {
            for (var i = 0; i < value.length; i++) {
              if (value[i] !== comparison[0][i]) {
                return true;
              }
            }
            return false;
          }
          return true;
        }
      },
      'null': {
        conditionName: function (dt, i18n) {
          return dt.i18n('searchBuilder.conditions.array.empty', i18n.conditions.array.empty);
        },
        init: Criteria.initNoValue,
        isInputValid: function () {
          return true;
        },
        inputValue: function () {
          return;
        },
        search: function (value) {
          return (value === null || value === undefined || value.length === 0);
        }
      },
      '!null': {
        conditionName: function (dt, i18n) {
          return dt.i18n('searchBuilder.conditions.array.notEmpty', i18n.conditions.array.notEmpty);
        },
        isInputValid: function () {
          return true;
        },
        init: Criteria.initNoValue,
        inputValue: function () {
          return;
        },
        search: function (value) {
          return (value !== null && value !== undefined && value.length !== 0);
        }
      }
    };
    Criteria.defaults = {
      columns: true,
      conditions: {
        'array': Criteria.arrayConditions,
        'date': Criteria.dateConditions,
        'html': Criteria.stringConditions,
        'html-num': Criteria.numConditions,
        'html-num-fmt': Criteria.numFmtConditions,
        'moment': Criteria.momentDateConditions,
        'num': Criteria.numConditions,
        'num-fmt': Criteria.numFmtConditions,
        'string': Criteria.stringConditions
      },
      depthLimit: false,
      filterChanged: undefined,
      greyscale: false,
      i18n: {
        add: 'Add Condition',
        button: {
          0: 'Search Builder',
          _: 'Search Builder (%d)'
        },
        clearAll: 'Clear All',
        condition: 'Condition',
        data: 'Data',
        deleteTitle: 'Delete filtering rule',
        leftTitle: 'Outdent criteria',
        logicAnd: 'And',
        logicOr: 'Or',
        rightTitle: 'Indent criteria',
        title: {
          0: 'Custom Search Builder',
          _: 'Custom Search Builder (%d)'
        },
        value: 'Value',
        valueJoiner: 'and'
      },
      logic: 'AND',
      orthogonal: {
        display: 'display',
        search: 'filter'
      },
      preDefined: false
    };
    return Criteria;
  }());

  var $$1;
  var DataTable$1;

  /**
   * Sets the value of jQuery for use in the file
   * @param jq the instance of jQuery to be set
   */
  function setJQuery$1(jq) {
    $$1 = jq;
    DataTable$1 = jq.fn.dataTable;
  }

  /**
   * The Group class is used within SearchBuilder to represent a group of criteria
   */
  var Group = /** @class */ (function () {
    function Group(table, opts, topGroup, index, isChild, depth) {
      if (index === void 0) {
        index = 0;
      }
      if (isChild === void 0) {
        isChild = false;
      }
      if (depth === void 0) {
        depth = 1;
      }
      // Check that the required version of DataTables is included
      if (!DataTable$1 || !DataTable$1.versionCheck || !DataTable$1.versionCheck('1.10.0')) {
        throw new Error('SearchBuilder requires DataTables 1.10 or newer');
      }
      this.classes = $$1.extend(true, {}, Group.classes);
      // Get options from user
      this.c = $$1.extend(true, {}, Group.defaults, opts);
      this.s = {
        criteria: [],
        depth: depth,
        dt: table,
        index: index,
        isChild: isChild,
        logic: undefined,
        opts: opts,
        toDrop: undefined,
        topGroup: topGroup
      };
      this.dom = {
        add: $$1('<button/>')
          .addClass(this.classes.add)
          .addClass(this.classes.button)
          .attr('type', 'button'),
        clear: $$1('<button>&times</button>')
          .addClass(this.classes.button)
          .addClass(this.classes.clearGroup)
          .attr('type', 'button'),
        container: $$1('<div/>')
          .addClass(this.classes.group),
        logic: $$1('<button/>')
          .addClass(this.classes.logic)
          .addClass(this.classes.button)
          .attr('type', 'button'),
        logicContainer: $$1('<div/>')
          .addClass(this.classes.logicContainer)
      };
      // A reference to the top level group is maintained throughout any subgroups and criteria that may be created
      if (this.s.topGroup === undefined) {
        this.s.topGroup = this.dom.container;
      }
      this._setup();
      return this;
    }

    /**
     * Destroys the groups buttons, clears the internal criteria and removes it from the dom
     */
    Group.prototype.destroy = function () {
      // Turn off listeners
      $$1(this.dom.add).off('.dtsb');
      $$1(this.dom.logic).off('.dtsb');
      // Trigger event for groups at a higher level to pick up on
      $$1(this.dom.container)
        .trigger('dtsb-destroy')
        .remove();
      this.s.criteria = [];
    };
    /**
     * Gets the details required to rebuild the group
     */
    Group.prototype.getDetails = function () {
      if (this.s.criteria.length === 0) {
        return {};
      }
      var details = {
        criteria: [],
        logic: this.s.logic
      };
      // NOTE here crit could be either a subgroup or a criteria
      for (var _i = 0, _a = this.s.criteria; _i < _a.length; _i++) {
        var crit = _a[_i];
        details.criteria.push(crit.criteria.getDetails());
      }
      return details;
    };
    /**
     * Getter for the node for the container of the group
     * @returns Node for the container of the group
     */
    Group.prototype.getNode = function () {
      return this.dom.container;
    };
    /**
     * Rebuilds the group based upon the details passed in
     * @param loadedDetails the details required to rebuild the group
     */
    Group.prototype.rebuild = function (loadedDetails) {
      // If no criteria are stored then just return
      if (loadedDetails.criteria === undefined || loadedDetails.criteria === null || loadedDetails.criteria.length === 0) {
        return;
      }
      this.s.logic = loadedDetails.logic;
      $$1(this.dom.logic).text(this.s.logic === 'OR'
        ? this.s.dt.i18n('searchBuilder.logicOr', this.c.i18n.logicOr)
        : this.s.dt.i18n('searchBuilder.logicAnd', this.c.i18n.logicAnd));
      // Add all of the criteria, be it a sub group or a criteria
      for (var _i = 0, _a = loadedDetails.criteria; _i < _a.length; _i++) {
        var crit = _a[_i];
        if (crit.logic !== undefined) {
          this._addPrevGroup(crit);
        } else if (crit.logic === undefined) {
          this._addPrevCriteria(crit);
        }
      }
      // For all of the criteria children, update the arrows incase they require changing and set the listeners
      for (var _b = 0, _c = this.s.criteria; _b < _c.length; _b++) {
        var crit = _c[_b];
        if (crit.criteria instanceof Criteria) {
          crit.criteria.updateArrows(this.s.criteria.length > 1, false);
          this._setCriteriaListeners(crit.criteria);
        }
      }
    };
    /**
     * Redraws the Contents of the searchBuilder Groups and Criteria
     */
    Group.prototype.redrawContents = function () {
      // Clear the container out and add the basic elements
      $$1(this.dom.container)
        .empty()
        .append(this.dom.logicContainer)
        .append(this.dom.add);
      // Sort the criteria by index so that they appear in the correct order
      this.s.criteria.sort(function (a, b) {
        if (a.criteria.s.index < b.criteria.s.index) {
          return -1;
        } else if (a.criteria.s.index > b.criteria.s.index) {
          return 1;
        }
        return 0;
      });
      this.setListeners();
      for (var i = 0; i < this.s.criteria.length; i++) {
        var crit = this.s.criteria[i].criteria;
        if (crit instanceof Criteria) {
          // Reset the index to the new value
          this.s.criteria[i].index = i;
          this.s.criteria[i].criteria.s.index = i;
          // Add to the group
          $$1(this.s.criteria[i].criteria.dom.container).insertBefore(this.dom.add);
          // Set listeners for various points
          this._setCriteriaListeners(crit);
          this.s.criteria[i].criteria.rebuild(this.s.criteria[i].criteria.getDetails());
        } else if (crit instanceof Group && crit.s.criteria.length > 0) {
          // Reset the index to the new value
          this.s.criteria[i].index = i;
          this.s.criteria[i].criteria.s.index = i;
          // Add the sub group to the group
          $$1(this.s.criteria[i].criteria.dom.container).insertBefore(this.dom.add);
          // Redraw the contents of the group
          crit.redrawContents();
          this._setGroupListeners(crit);
        } else {
          // The group is empty so remove it
          this.s.criteria.splice(i, 1);
          i--;
        }
      }
      this.setupLogic();
    };
    /**
     * Search method, checking the row data against the criteria in the group
     * @param rowData The row data to be compared
     * @returns boolean The result of the search
     */
    Group.prototype.search = function (rowData, rowIdx) {
      if (this.s.logic === 'AND') {
        return this._andSearch(rowData, rowIdx);
      } else if (this.s.logic === 'OR') {
        return this._orSearch(rowData, rowIdx);
      }
      return true;
    };
    /**
     * Locates the groups logic button to the correct location on the page
     */
    Group.prototype.setupLogic = function () {
      // Remove logic button
      $$1(this.dom.logicContainer).remove();
      $$1(this.dom.clear).remove();
      // If there are no criteria in the group then keep the logic removed and return
      if (this.s.criteria.length < 1) {
        if (!this.s.isChild) {
          $$1(this.dom.container).trigger('dtsb-destroy');
          // Set criteria left margin
          $$1(this.dom.container).css('margin-left', 0);
        }
        return;
      }
      // Set width, take 2 for the border
      var height = $$1(this.dom.container).height() - 2;
      $$1(this.dom.clear).height('0px');
      $$1(this.dom.logicContainer).append(this.dom.clear).width(height);
      // Prepend logic button
      $$1(this.dom.container).prepend(this.dom.logicContainer);
      this._setLogicListener();
      // Set criteria left margin
      $$1(this.dom.container).css('margin-left', $$1(this.dom.logicContainer).outerHeight(true));
      var logicOffset = $$1(this.dom.logicContainer).offset();
      // Set horizontal alignment
      var currentLeft = logicOffset.left;
      var groupLeft = $$1(this.dom.container).offset().left;
      var shuffleLeft = currentLeft - groupLeft;
      var newPos = currentLeft - shuffleLeft - $$1(this.dom.logicContainer).outerHeight(true);
      $$1(this.dom.logicContainer).offset({left: newPos});
      // Set vertical alignment
      var firstCrit = $$1(this.dom.logicContainer).next();
      var currentTop = logicOffset.top;
      var firstTop = $$1(firstCrit).offset().top;
      var shuffleTop = currentTop - firstTop;
      var newTop = currentTop - shuffleTop;
      $$1(this.dom.logicContainer).offset({top: newTop});
      $$1(this.dom.clear).outerHeight($$1(this.dom.logicContainer).height());
      this._setClearListener();
    };
    /**
     * Sets listeners on the groups elements
     */
    Group.prototype.setListeners = function () {
      var _this = this;
      $$1(this.dom.add).unbind('click');
      $$1(this.dom.add).on('click', function () {
        // If this is the parent group then the logic button has not been added yet
        if (!_this.s.isChild) {
          $$1(_this.dom.container).prepend(_this.dom.logicContainer);
        }
        _this.addCriteria();
        $$1(_this.dom.container).trigger('dtsb-add');
        _this.s.dt.state.save();
        return false;
      });
      for (var _i = 0, _a = this.s.criteria; _i < _a.length; _i++) {
        var crit = _a[_i];
        crit.criteria.setListeners();
      }
      this._setClearListener();
      this._setLogicListener();
    };
    /**
     * Adds a criteria to the group
     * @param crit Instance of Criteria to be added to the group
     */
    Group.prototype.addCriteria = function (crit, redraw) {
      if (crit === void 0) {
        crit = null;
      }
      if (redraw === void 0) {
        redraw = true;
      }
      var index = crit === null ? this.s.criteria.length : crit.s.index;
      var criteria = new Criteria(this.s.dt, this.s.opts, this.s.topGroup, index, this.s.depth);
      // If a Criteria has been passed in then set the values to continue that
      if (crit !== null) {
        criteria.c = crit.c;
        criteria.s = crit.s;
        criteria.s.depth = this.s.depth;
        criteria.classes = crit.classes;
      }
      criteria.populate();
      var inserted = false;
      for (var i = 0; i < this.s.criteria.length; i++) {
        if (i === 0 && this.s.criteria[i].criteria.s.index > criteria.s.index) {
          // Add the node for the criteria at the start of the group
          $$1(criteria.getNode()).insertBefore(this.s.criteria[i].criteria.dom.container);
          inserted = true;
        } else if (i < this.s.criteria.length - 1 &&
          this.s.criteria[i].criteria.s.index < criteria.s.index &&
          this.s.criteria[i + 1].criteria.s.index > criteria.s.index) {
          // Add the node for the criteria in the correct location
          $$1(criteria.getNode()).insertAfter(this.s.criteria[i].criteria.dom.container);
          inserted = true;
        }
      }
      if (!inserted) {
        $$1(criteria.getNode()).insertBefore(this.dom.add);
      }
      // Add the details for this criteria to the array
      this.s.criteria.push({
        criteria: criteria,
        index: index
      });
      this.s.criteria = this.s.criteria.sort(function (a, b) {
        return a.criteria.s.index - b.criteria.s.index;
      });
      for (var _i = 0, _a = this.s.criteria; _i < _a.length; _i++) {
        var opt = _a[_i];
        if (opt.criteria instanceof Criteria) {
          opt.criteria.updateArrows(this.s.criteria.length > 1, redraw);
        }
      }
      this._setCriteriaListeners(criteria);
      criteria.setListeners();
      this.setupLogic();
    };
    /**
     * Checks the group to see if it has any filled criteria
     */
    Group.prototype.checkFilled = function () {
      for (var _i = 0, _a = this.s.criteria; _i < _a.length; _i++) {
        var crit = _a[_i];
        if ((crit.criteria instanceof Criteria && crit.criteria.s.filled) ||
          (crit.criteria instanceof Group && crit.criteria.checkFilled())) {
          return true;
        }
      }
      return false;
    };
    /**
     * Gets the count for the number of criteria in this group and any sub groups
     */
    Group.prototype.count = function () {
      var count = 0;
      for (var _i = 0, _a = this.s.criteria; _i < _a.length; _i++) {
        var crit = _a[_i];
        if (crit.criteria instanceof Group) {
          count += crit.criteria.count();
        } else {
          count++;
        }
      }
      return count;
    };
    /**
     * Rebuilds a sub group that previously existed
     * @param loadedGroup The details of a group within this group
     */
    Group.prototype._addPrevGroup = function (loadedGroup) {
      var idx = this.s.criteria.length;
      var group = new Group(this.s.dt, this.c, this.s.topGroup, idx, true, this.s.depth + 1);
      // Add the new group to the criteria array
      this.s.criteria.push({
        criteria: group,
        index: idx,
        logic: group.s.logic
      });
      // Rebuild it with the previous conditions for that group
      group.rebuild(loadedGroup);
      this.s.criteria[idx].criteria = group;
      $$1(this.s.topGroup).trigger('dtsb-redrawContents');
      this._setGroupListeners(group);
    };
    /**
     * Rebuilds a criteria of this group that previously existed
     * @param loadedCriteria The details of a criteria within the group
     */
    Group.prototype._addPrevCriteria = function (loadedCriteria) {
      var idx = this.s.criteria.length;
      var criteria = new Criteria(this.s.dt, this.s.opts, this.s.topGroup, idx, this.s.depth);
      criteria.populate();
      // Add the new criteria to the criteria array
      this.s.criteria.push({
        criteria: criteria,
        index: idx
      });
      // Rebuild it with the previous conditions for that criteria
      criteria.rebuild(loadedCriteria);
      this.s.criteria[idx].criteria = criteria;
      $$1(this.s.topGroup).trigger('dtsb-redrawContents');
    };
    /**
     * Checks And the criteria using AND logic
     * @param rowData The row data to be checked against the search criteria
     * @returns boolean The result of the AND search
     */
    Group.prototype._andSearch = function (rowData, rowIdx) {
      // If there are no criteria then return true for this group
      if (this.s.criteria.length === 0) {
        return true;
      }
      for (var _i = 0, _a = this.s.criteria; _i < _a.length; _i++) {
        var crit = _a[_i];
        // If the criteria is not complete then skip it
        if (crit.criteria instanceof Criteria && !crit.criteria.s.filled) {
          continue;
        }
        // Otherwise if a single one fails return false
        else if (!crit.criteria.search(rowData, rowIdx)) {
          return false;
        }
      }
      // If we get to here then everything has passed, so return true for the group
      return true;
    };
    /**
     * Checks And the criteria using OR logic
     * @param rowData The row data to be checked against the search criteria
     * @returns boolean The result of the OR search
     */
    Group.prototype._orSearch = function (rowData, rowIdx) {
      // If there are no criteria in the group then return true
      if (this.s.criteria.length === 0) {
        return true;
      }
      // This will check to make sure that at least one criteria in the group is complete
      var filledfound = false;
      for (var _i = 0, _a = this.s.criteria; _i < _a.length; _i++) {
        var crit = _a[_i];
        if (crit.criteria instanceof Criteria && crit.criteria.s.filled) {
          // A completed criteria has been found so set the flag
          filledfound = true;
          // If the search passes then return true
          if (crit.criteria.search(rowData, rowIdx)) {
            return true;
          }
        } else if (crit.criteria instanceof Group && crit.criteria.checkFilled()) {
          filledfound = true;
          if (crit.criteria.search(rowData, rowIdx)) {
            return true;
          }
        }
      }
      // If we get here we need to return the inverse of filledfound,
      //  as if any have been found and we are here then none have passed
      return !filledfound;
    };
    /**
     * Removes a criteria from the group
     * @param criteria The criteria instance to be removed
     */
    Group.prototype._removeCriteria = function (criteria, group) {
      if (group === void 0) {
        group = false;
      }
      // If removing a criteria and there is only then then just destroy the group
      if (this.s.criteria.length <= 1 && this.s.isChild) {
        this.destroy();
      } else {
        // Otherwise splice the given criteria out and redo the indexes
        var last = void 0;
        for (var i = 0; i < this.s.criteria.length; i++) {
          if (this.s.criteria[i].index === criteria.s.index && (!group || this.s.criteria[i].criteria instanceof Group)) {
            last = i;
          }
        }
        // We want to remove the last element with the desired index, as its replacement will be inserted before it
        if (last !== undefined) {
          this.s.criteria.splice(last, 1);
        }
        for (var i = 0; i < this.s.criteria.length; i++) {
          this.s.criteria[i].index = i;
          this.s.criteria[i].criteria.s.index = i;
        }
      }
    };
    /**
     * Sets the listeners in group for a criteria
     * @param criteria The criteria for the listeners to be set on
     */
    Group.prototype._setCriteriaListeners = function (criteria) {
      var _this = this;
      $$1(criteria.dom["delete"])
        .unbind('click')
        .on('click', function () {
          _this._removeCriteria(criteria);
          $$1(criteria.dom.container).remove();
          for (var _i = 0, _a = _this.s.criteria; _i < _a.length; _i++) {
            var crit = _a[_i];
            if (crit.criteria instanceof Criteria) {
              crit.criteria.updateArrows(_this.s.criteria.length > 1);
            }
          }
          criteria.destroy();
          _this.s.dt.draw();
          $$1(_this.s.topGroup).trigger('dtsb-redrawContents');
          $$1(_this.s.topGroup).trigger('dtsb-updateTitle');
          return false;
        });
      $$1(criteria.dom.right)
        .unbind('click')
        .on('click', function () {
          var idx = criteria.s.index;
          var group = new Group(_this.s.dt, _this.s.opts, _this.s.topGroup, criteria.s.index, true, _this.s.depth + 1);
          // Add the criteria that is to be moved to the new group
          group.addCriteria(criteria);
          // Update the details in the current groups criteria array
          _this.s.criteria[idx].criteria = group;
          _this.s.criteria[idx].logic = 'AND';
          $$1(_this.s.topGroup).trigger('dtsb-redrawContents');
          _this._setGroupListeners(group);
          return false;
        });
      $$1(criteria.dom.left)
        .unbind('click')
        .on('click', function () {
          _this.s.toDrop = new Criteria(_this.s.dt, _this.s.opts, _this.s.topGroup, criteria.s.index);
          _this.s.toDrop.s = criteria.s;
          _this.s.toDrop.c = criteria.c;
          _this.s.toDrop.classes = criteria.classes;
          _this.s.toDrop.populate();
          // The dropCriteria event mutates the reference to the index so need to store it
          var index = _this.s.toDrop.s.index;
          $$1(_this.dom.container).trigger('dtsb-dropCriteria');
          criteria.s.index = index;
          _this._removeCriteria(criteria);
          // By tracking the top level group we can directly trigger a redraw on it,
          //  bubbling is also possible, but that is slow with deep levelled groups
          $$1(_this.s.topGroup).trigger('dtsb-redrawContents');
          _this.s.dt.draw();
          return false;
        });
    };
    /**
     * Set's the listeners for the group clear button
     */
    Group.prototype._setClearListener = function () {
      var _this = this;
      $$1(this.dom.clear)
        .unbind('click')
        .on('click', function () {
          if (!_this.s.isChild) {
            $$1(_this.dom.container).trigger('dtsb-clearContents');
            return false;
          }
          _this.destroy();
          $$1(_this.s.topGroup).trigger('dtsb-updateTitle');
          $$1(_this.s.topGroup).trigger('dtsb-redrawContents');
          return false;
        });
    };
    /**
     * Sets listeners for sub groups of this group
     * @param group The sub group that the listeners are to be set on
     */
    Group.prototype._setGroupListeners = function (group) {
      var _this = this;
      // Set listeners for the new group
      $$1(group.dom.add)
        .unbind('click')
        .on('click', function () {
          _this.setupLogic();
          $$1(_this.dom.container).trigger('dtsb-add');
          return false;
        });
      $$1(group.dom.container)
        .unbind('dtsb-add')
        .on('dtsb-add', function () {
          _this.setupLogic();
          $$1(_this.dom.container).trigger('dtsb-add');
          return false;
        });
      $$1(group.dom.container)
        .unbind('dtsb-destroy')
        .on('dtsb-destroy', function () {
          _this._removeCriteria(group, true);
          $$1(group.dom.container).remove();
          _this.setupLogic();
          return false;
        });
      $$1(group.dom.container)
        .unbind('dtsb-dropCriteria')
        .on('dtsb-dropCriteria', function () {
          var toDrop = group.s.toDrop;
          toDrop.s.index = group.s.index;
          toDrop.updateArrows(_this.s.criteria.length > 1, false);
          _this.addCriteria(toDrop, false);
          return false;
        });
      group.setListeners();
    };
    /**
     * Sets up the Group instance, setting listeners and appending elements
     */
    Group.prototype._setup = function () {
      this.setListeners();
      $$1(this.dom.add).text(this.s.dt.i18n('searchBuilder.add', this.c.i18n.add));
      $$1(this.dom.logic).text(this.c.logic === 'OR'
        ? this.s.dt.i18n('searchBuilder.logicOr', this.c.i18n.logicOr)
        : this.s.dt.i18n('searchBuilder.logicAnd', this.c.i18n.logicAnd));
      this.s.logic = this.c.logic === 'OR' ? 'OR' : 'AND';
      if (this.c.greyscale) {
        $$1(this.dom.logic).addClass(this.classes.greyscale);
      }
      $$1(this.dom.logicContainer).append(this.dom.logic).append(this.dom.clear);
      // Only append the logic button immediately if this is a sub group,
      //  otherwise it will be prepended later when adding a criteria
      if (this.s.isChild) {
        $$1(this.dom.container).append(this.dom.logicContainer);
      }
      $$1(this.dom.container).append(this.dom.add);
    };
    /**
     * Sets the listener for the logic button
     */
    Group.prototype._setLogicListener = function () {
      var _this = this;
      $$1(this.dom.logic)
        .unbind('click')
        .on('click', function () {
          _this._toggleLogic();
          _this.s.dt.draw();
          for (var _i = 0, _a = _this.s.criteria; _i < _a.length; _i++) {
            var crit = _a[_i];
            crit.criteria.setListeners();
          }
        });
    };
    /**
     * Toggles the logic for the group
     */
    Group.prototype._toggleLogic = function () {
      if (this.s.logic === 'OR') {
        this.s.logic = 'AND';
        $$1(this.dom.logic).text(this.s.dt.i18n('searchBuilder.logicAnd', this.c.i18n.logicAnd));
      } else if (this.s.logic === 'AND') {
        this.s.logic = 'OR';
        $$1(this.dom.logic).text(this.s.dt.i18n('searchBuilder.logicOr', this.c.i18n.logicOr));
      }
    };
    Group.version = '1.0.0';
    Group.classes = {
      add: 'dtsb-add',
      button: 'dtsb-button',
      clearGroup: 'dtsb-clearGroup',
      greyscale: 'dtsb-greyscale',
      group: 'dtsb-group',
      inputButton: 'dtsb-iptbtn',
      logic: 'dtsb-logic',
      logicContainer: 'dtsb-logicContainer'
    };
    Group.defaults = {
      columns: true,
      conditions: {
        'date': Criteria.dateConditions,
        'html': Criteria.stringConditions,
        'html-num': Criteria.numConditions,
        'html-num-fmt': Criteria.numFmtConditions,
        'moment': Criteria.momentDateConditions,
        'num': Criteria.numConditions,
        'num-fmt': Criteria.numFmtConditions,
        'string': Criteria.stringConditions
      },
      depthLimit: false,
      filterChanged: undefined,
      greyscale: false,
      i18n: {
        add: 'Add Condition',
        button: {
          0: 'Search Builder',
          _: 'Search Builder (%d)'
        },
        clearAll: 'Clear All',
        condition: 'Condition',
        data: 'Data',
        deleteTitle: 'Delete filtering rule',
        leftTitle: 'Outdent criteria',
        logicAnd: 'And',
        logicOr: 'Or',
        rightTitle: 'Indent criteria',
        title: {
          0: 'Custom Search Builder',
          _: 'Custom Search Builder (%d)'
        },
        value: 'Value',
        valueJoiner: 'and'
      },
      logic: 'AND',
      orthogonal: {
        display: 'display',
        search: 'filter'
      },
      preDefined: false
    };
    return Group;
  }());

  var $$2;
  var DataTable$2;

  /**
   * Sets the value of jQuery for use in the file
   * @param jq the instance of jQuery to be set
   */
  function setJQuery$2(jq) {
    $$2 = jq;
    DataTable$2 = jq.fn.DataTable;
  }

  /**
   * SearchBuilder class for DataTables.
   * Allows for complex search queries to be constructed and implemented on a DataTable
   */
  var SearchBuilder = /** @class */ (function () {
    function SearchBuilder(builderSettings, opts) {
      var _this = this;
      // Check that the required version of DataTables is included
      if (!DataTable$2 || !DataTable$2.versionCheck || !DataTable$2.versionCheck('1.10.0')) {
        throw new Error('SearchBuilder requires DataTables 1.10 or newer');
      }
      var table = new DataTable$2.Api(builderSettings);
      this.classes = $$2.extend(true, {}, SearchBuilder.classes);
      // Get options from user
      this.c = $$2.extend(true, {}, SearchBuilder.defaults, opts);
      this.dom = {
        clearAll: $$2('<button type="button">' + table.i18n('searchBuilder.clearAll', this.c.i18n.clearAll) + '</button>')
          .addClass(this.classes.clearAll)
          .addClass(this.classes.button)
          .attr('type', 'button'),
        container: $$2('<div/>')
          .addClass(this.classes.container),
        title: $$2('<div/>')
          .addClass(this.classes.title),
        titleRow: $$2('<div/>')
          .addClass(this.classes.titleRow),
        topGroup: undefined
      };
      this.s = {
        dt: table,
        opts: opts,
        search: undefined,
        topGroup: undefined
      };
      // If searchbuilder is already defined for this table then return
      if (table.settings()[0]._searchBuilder !== undefined) {
        return;
      }
      table.settings()[0]._searchBuilder = this;
      // Run the remaining setup when the table is initialised
      if (this.s.dt.settings()[0]._bInitComplete) {
        this._setUp();
      } else {
        table.one('init.dt', function () {
          _this._setUp();
        });
      }
      return this;
    }

    /**
     * Gets the details required to rebuild the SearchBuilder as it currently is
     */
    SearchBuilder.prototype.getDetails = function () {
      return this.s.topGroup.getDetails();
    };
    /**
     * Getter for the node of the container for the searchBuilder
     * @returns JQuery<HTMLElement> the node of the container
     */
    SearchBuilder.prototype.getNode = function () {
      return this.dom.container;
    };
    /**
     * Rebuilds the SearchBuilder to a state that is provided
     * @param details The details required to perform a rebuild
     */
    SearchBuilder.prototype.rebuild = function (details) {
      $$2(this.dom.clearAll).click();
      // If there are no details to rebuild then return
      if (details === undefined || details === null) {
        return this;
      }
      this.s.topGroup.rebuild(details);
      this.s.dt.draw();
      this.s.topGroup.setListeners();
      return this;
    };
    /**
     * Applies the defaults to preDefined criteria
     * @param preDef the array of criteria to be processed.
     */
    SearchBuilder.prototype._applyPreDefDefaults = function (preDef) {
      var _this = this;
      if (preDef.criteria !== undefined && preDef.logic === undefined) {
        preDef.logic = 'AND';
      }
      var _loop_1 = function (crit) {
        // Apply the defaults to any further criteria
        if (crit.criteria !== undefined) {
          crit = this_1._applyPreDefDefaults(crit);
        } else {
          this_1.s.dt.columns().every(function (index) {
            if (_this.s.dt.settings()[0].aoColumns[index].sTitle === crit.data) {
              crit.dataIdx = index;
            }
          });
        }
      };
      var this_1 = this;
      for (var _i = 0, _a = preDef.criteria; _i < _a.length; _i++) {
        var crit = _a[_i];
        _loop_1(crit);
      }
      return preDef;
    };
    /**
     * Set's up the SearchBuilder
     */
    SearchBuilder.prototype._setUp = function (loadState) {
      var _this = this;
      if (loadState === void 0) {
        loadState = true;
      }
      this.s.topGroup = new Group(this.s.dt, this.c, undefined);
      this._setClearListener();
      this.s.dt.on('stateSaveParams', function (e, settings, data) {
        data.searchBuilder = _this.getDetails();
        data.page = _this.s.dt.page();
      });
      this._build();
      if (loadState) {
        var loadedState = this.s.dt.state.loaded();
        // If the loaded State is not null rebuild based on it for statesave
        if (loadedState !== null && loadedState.searchBuilder !== undefined) {
          this.s.topGroup.rebuild(loadedState.searchBuilder);
          $$2(this.s.topGroup.dom.container).trigger('dtsb-redrawContents');
          this.s.dt.page(loadedState.page).draw('page');
          this.s.topGroup.setListeners();
        }
        // Otherwise load any predefined options
        else if (this.c.preDefined !== false) {
          this.c.preDefined = this._applyPreDefDefaults(this.c.preDefined);
          this.rebuild(this.c.preDefined);
        }
      }
      this._setEmptyListener();
      this.s.dt.state.save();
    };
    /**
     * Updates the title of the SearchBuilder
     * @param count the number of filters in the SearchBuilder
     */
    SearchBuilder.prototype._updateTitle = function (count) {
      $$2(this.dom.title).text(this.s.dt.i18n('searchBuilder.title', this.c.i18n.title, count));
    };
    /**
     * Builds all of the dom elements together
     */
    SearchBuilder.prototype._build = function () {
      var _this = this;
      // Empty and setup the container
      $$2(this.dom.clearAll).remove();
      $$2(this.dom.container).empty();
      var count = this.s.topGroup.count();
      this._updateTitle(count);
      $$2(this.dom.titleRow).append(this.dom.title);
      $$2(this.dom.container).append(this.dom.titleRow);
      this.dom.topGroup = this.s.topGroup.getNode();
      $$2(this.dom.container).append(this.dom.topGroup);
      this._setRedrawListener();
      var tableNode = this.s.dt.table(0).node();
      if ($$2.fn.dataTable.ext.search.indexOf(this.s.search) === -1) {
        // Custom search function for SearchBuilder
        this.s.search = function (settings, searchData, dataIndex, origData) {
          if (settings.nTable !== tableNode) {
            return true;
          }
          return _this.s.topGroup.search(searchData, dataIndex);
        };
        // Add SearchBuilder search function to the dataTables search array
        $$2.fn.dataTable.ext.search.push(this.s.search);
      }
      // Register an Api method for getting the column type
      $$2.fn.DataTable.Api.registerPlural('columns().type()', 'column().type()', function (selector, opts) {
        return this.iterator('column', function (settings, column) {
          return settings.aoColumns[column].sType;
        }, 1);
      });
      this.s.dt.on('destroy.dt', function () {
        $$2(_this.dom.container).remove();
        $$2(_this.dom.clearAll).remove();
        var searchIdx = $$2.fn.dataTable.ext.search.indexOf(_this.s.search);
        while (searchIdx !== -1) {
          $$2.fn.dataTable.ext.search.splice(searchIdx, 1);
          searchIdx = $$2.fn.dataTable.ext.search.indexOf(_this.s.search);
        }
      });
    };
    /**
     * Checks if the clearAll button should be added or not
     */
    SearchBuilder.prototype._checkClear = function () {
      if (this.s.topGroup.s.criteria.length > 0) {
        $$2(this.dom.clearAll).insertAfter(this.dom.title);
        this._setClearListener();
      } else {
        $$2(this.dom.clearAll).remove();
      }
    };
    /**
     * Update the count in the title/button
     * @param count Number of filters applied
     */
    SearchBuilder.prototype._filterChanged = function (count) {
      var fn = this.c.filterChanged;
      if (typeof fn === 'function') {
        fn(count, this.s.dt.i18n('searchBuilder.button', this.c.i18n.button, count));
      }
    };
    /**
     * Set the listener for the clear button
     */
    SearchBuilder.prototype._setClearListener = function () {
      var _this = this;
      $$2(this.dom.clearAll).unbind('click');
      $$2(this.dom.clearAll).on('click', function () {
        _this.s.topGroup = new Group(_this.s.dt, _this.c, undefined);
        _this._build();
        _this.s.dt.draw();
        _this.s.topGroup.setListeners();
        $$2(_this.dom.clearAll).remove();
        _this._setEmptyListener();
        _this._filterChanged(0);
        return false;
      });
    };
    /**
     * Set the listener for the Redraw event
     */
    SearchBuilder.prototype._setRedrawListener = function () {
      var _this = this;
      $$2(this.s.topGroup.dom.container).unbind('dtsb-redrawContents');
      $$2(this.s.topGroup.dom.container).on('dtsb-redrawContents', function () {
        _this._checkClear();
        _this.s.topGroup.redrawContents();
        _this.s.topGroup.setupLogic();
        _this._setEmptyListener();
        var count = _this.s.topGroup.count();
        _this._updateTitle(count);
        _this._filterChanged(count);
        _this.s.dt.state.save();
      });
      $$2(this.s.topGroup.dom.container).unbind('dtsb-clearContents');
      $$2(this.s.topGroup.dom.container).on('dtsb-clearContents', function () {
        _this._setUp(false);
        _this._filterChanged(0);
        _this.s.dt.draw();
      });
      $$2(this.s.topGroup.dom.container).on('dtsb-updateTitle', function () {
        var count = _this.s.topGroup.count();
        _this._updateTitle(count);
        _this._filterChanged(count);
      });
    };
    /**
     * Sets listeners to check whether clearAll should be added or removed
     */
    SearchBuilder.prototype._setEmptyListener = function () {
      var _this = this;
      $$2(this.s.topGroup.dom.add).on('click', function () {
        _this._checkClear();
      });
      $$2(this.s.topGroup.dom.container).on('dtsb-destroy', function () {
        $$2(_this.dom.clearAll).remove();
      });
    };
    SearchBuilder.version = '1.0.1';
    SearchBuilder.classes = {
      button: 'dtsb-button',
      clearAll: 'dtsb-clearAll',
      container: 'dtsb-searchBuilder',
      inputButton: 'dtsb-iptbtn',
      title: 'dtsb-title',
      titleRow: 'dtsb-titleRow'
    };
    SearchBuilder.defaults = {
      columns: true,
      conditions: {
        'date': Criteria.dateConditions,
        'html': Criteria.stringConditions,
        'html-num': Criteria.numConditions,
        'html-num-fmt': Criteria.numFmtConditions,
        'moment': Criteria.momentDateConditions,
        'num': Criteria.numConditions,
        'num-fmt': Criteria.numFmtConditions,
        'string': Criteria.stringConditions
      },
      depthLimit: false,
      filterChanged: undefined,
      greyscale: false,
      i18n: {
        add: 'Add Condition',
        button: {
          0: 'Search Builder',
          _: 'Search Builder (%d)'
        },
        clearAll: 'Clear All',
        condition: 'Condition',
        conditions: {
          array: {
            contains: 'Contains',
            empty: 'Empty',
            equals: 'Equals',
            not: 'Not',
            notEmpty: 'Not Empty',
            without: 'Without'
          },
          date: {
            after: 'After',
            before: 'Before',
            between: 'Between',
            empty: 'Empty',
            equals: 'Equals',
            not: 'Not',
            notBetween: 'Not Between',
            notEmpty: 'Not Empty'
          },
          moment: {
            after: 'After',
            before: 'Before',
            between: 'Between',
            empty: 'Empty',
            equals: 'Equals',
            not: 'Not',
            notBetween: 'Not Between',
            notEmpty: 'Not Empty'
          },
          number: {
            between: 'Between',
            empty: 'Empty',
            equals: 'Equals',
            gt: 'Greater Than',
            gte: 'Greater Than Equal To',
            lt: 'Less Than',
            lte: 'Less Than Equal To',
            not: 'Not',
            notBetween: 'Not Between',
            notEmpty: 'Not Empty'
          },
          string: {
            contains: 'Contains',
            empty: 'Empty',
            endsWith: 'Ends With',
            equals: 'Equals',
            not: 'Not',
            notEmpty: 'Not Empty',
            startsWith: 'Starts With'
          }
        },
        data: 'Data',
        deleteTitle: 'Delete filtering rule',
        leftTitle: 'Outdent criteria',
        logicAnd: 'And',
        logicOr: 'Or',
        rightTitle: 'Indent criteria',
        title: {
          0: 'Custom Search Builder',
          _: 'Custom Search Builder (%d)'
        },
        value: 'Value',
        valueJoiner: 'and'
      },
      logic: 'AND',
      orthogonal: {
        display: 'display',
        search: 'filter'
      },
      preDefined: false
    };
    return SearchBuilder;
  }());

  /*! SearchBuilder 1.0.1
	 * ©2020 SpryMedia Ltd - datatables.net/license/mit
	 */
  // DataTables extensions common UMD. Note that this allows for AMD, CommonJS
  // (with window and jQuery being allowed as parameters to the returned
  // function) or just default browser loading.
  (function (factory) {
    if (typeof define === 'function' && define.amd) {
      // AMD
      define(['jquery', 'datatables.net'], function ($) {
        return factory($, window, document);
      });
    } else if (typeof exports === 'object') {
      // CommonJS
      module.exports = function (root, $) {
        if (!root) {
          root = window;
        }
        if (!$ || !$.fn.dataTable) {
          $ = require('datatables.net')(root, $).$;
        }
        return factory($, root, root.document);
      };
    } else {
      // Browser - assume jQuery has already been loaded
      factory(window.jQuery, window, document);
    }
  }(function ($, window, document) {
    setJQuery$2($);
    setJQuery$1($);
    setJQuery($);
    var DataTable = $.fn.dataTable;
    $.fn.dataTable.SearchBuilder = SearchBuilder;
    $.fn.DataTable.SearchBuilder = SearchBuilder;
    $.fn.dataTable.Group = Group;
    $.fn.DataTable.Group = Group;
    $.fn.dataTable.Criteria = Criteria;
    $.fn.DataTable.Criteria = Criteria;
    var apiRegister = $.fn.dataTable.Api.register;
    // Set up object for plugins
    $.fn.dataTable.ext.searchBuilder = {
      conditions: {}
    };
    $.fn.dataTable.ext.buttons.searchBuilder = {
      action: function (e, dt, node, config) {
        e.stopPropagation();
        this.popover(config._searchBuilder.getNode(), {
          align: 'dt-container'
        });
      },
      config: {},
      init: function (dt, node, config) {
        var sb = new $.fn.dataTable.SearchBuilder(dt, $.extend({
          filterChanged: function (count, text) {
            dt.button(node).text(text);
          }
        }, config.config));
        dt.button(node).text(config.text || dt.i18n('searchBuilder.button', sb.c.i18n.button, 0));
        config._searchBuilder = sb;
      },
      text: null
    };
    apiRegister('searchBuilder.getDetails()', function () {
      var ctx = this.context[0];
      return ctx._searchBuilder.getDetails();
    });
    apiRegister('searchBuilder.rebuild()', function (details) {
      var ctx = this.context[0];
      ctx._searchBuilder.rebuild(details);
      return this;
    });
    apiRegister('searchBuilder.container()', function () {
      var ctx = this.context[0];
      return ctx._searchBuilder.getNode();
    });

    /**
     * Init function for SearchBuilder
     * @param settings the settings to be applied
     * @param options the options for SearchBuilder
     * @returns JQUERY<HTMLElement> Returns the node of the SearchBuilder
     */
    function _init(settings, options) {
      var api = new DataTable.Api(settings);
      var opts = options
        ? options
        : api.init().searchBuilder || DataTable.defaults.searchBuilder;
      var searchBuilder = new SearchBuilder(api, opts);
      var node = searchBuilder.getNode();
      return node;
    }

    // Attach a listener to the document which listens for DataTables initialisation
    // events so we can automatically initialise
    $(document).on('preInit.dt.dtsp', function (e, settings, json) {
      if (e.namespace !== 'dt') {
        return;
      }
      if (settings.oInit.searchBuilder ||
        DataTable.defaults.searchBuilder) {
        if (!settings._searchBuilder) {
          _init(settings);
        }
      }
    });
    // DataTables `dom` feature option
    DataTable.ext.feature.push({
      cFeature: 'Q',
      fnInit: _init
    });
    // DataTables 2 layout feature
    if (DataTable.ext.features) {
      DataTable.ext.features.register('searchBuilder', _init);
    }
  }));

}());
